Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
react-compiler-runtime
Advanced tools
react-compiler-runtime - npm Package Compare versions
Comparing version 0.0.0-experimental-19cbb8f-20241107 to 0.0.0-experimental-1a59184-20250113
@@ -1,19 +0,26 @@ | ||
| type MemoCache = Array<number | typeof $empty>; | ||
| declare const $empty: unique symbol; | ||
| export declare const c: any; | ||
| declare enum GuardKind { | ||
| PushGuardContext = 0, | ||
| PopGuardContext = 1, | ||
| PushExpectHook = 2, | ||
| PopExpectHook = 3 | ||
| declare module 'react-compiler-runtime/index' { | ||
| type MemoCache = Array<number | typeof $empty>; | ||
| const $empty: unique symbol; | ||
| export const c: any; | ||
| enum GuardKind { | ||
| PushGuardContext = 0, | ||
| PopGuardContext = 1, | ||
| PushExpectHook = 2, | ||
| PopExpectHook = 3 | ||
| } | ||
| export function $dispatcherGuard(kind: GuardKind): void; | ||
| export function $reset($: MemoCache): void; | ||
| export function $makeReadOnly(): void; | ||
| export const renderCounterRegistry: Map<string, Set<{ | ||
| count: number; | ||
| }>>; | ||
| export function clearRenderCounterRegistry(): void; | ||
| export function useRenderCounter(name: string): void; | ||
| export function $structuralCheck(oldValue: any, newValue: any, variableName: string, fnName: string, kind: string, loc: string): void; | ||
| export {}; | ||
| } | ||
| export declare function $dispatcherGuard(kind: GuardKind): void; | ||
| export declare function $reset($: MemoCache): void; | ||
| export declare function $makeReadOnly(): void; | ||
| export declare const renderCounterRegistry: Map<string, Set<{ | ||
| count: number; | ||
| }>>; | ||
| export declare function clearRenderCounterRegistry(): void; | ||
| export declare function useRenderCounter(name: string): void; | ||
| export declare function $structuralCheck(oldValue: any, newValue: any, variableName: string, fnName: string, kind: string, loc: string): void; | ||
| export {}; | ||
| declare module 'react-compiler-runtime' { | ||
| import main = require('react-compiler-runtime/src/index'); | ||
| export = main; | ||
| } |
@@ -14,312 +14,362 @@ /** | ||
| "use no memo";'use strict'; | ||
| "use no memo"; | ||
| "use strict"; | ||
| var __create = Object.create; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __getProtoOf = Object.getPrototypeOf; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | ||
| // If the importer is in node compatibility mode or this is not an ESM | ||
| // file that has been converted to a CommonJS file using a Babel- | ||
| // compatible transform (i.e. "__esModule" has not been set), then set | ||
| // "default" to the CommonJS "module.exports" for node compatibility. | ||
| isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | ||
| mod | ||
| )); | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| var React = require('react'); | ||
| function _interopNamespaceDefault(e) { | ||
| var n = Object.create(null); | ||
| if (e) { | ||
| Object.keys(e).forEach(function (k) { | ||
| if (k !== 'default') { | ||
| var d = Object.getOwnPropertyDescriptor(e, k); | ||
| Object.defineProperty(n, k, d.get ? d : { | ||
| enumerable: true, | ||
| get: function () { return e[k]; } | ||
| }); | ||
| } | ||
| }); | ||
| } | ||
| n.default = e; | ||
| return Object.freeze(n); | ||
| } | ||
| var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React); | ||
| var _a, _b; | ||
| const { useRef, useEffect, isValidElement } = React__namespace; | ||
| const ReactSecretInternals = (_a = React__namespace.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE) !== null && _a !== void 0 ? _a : React__namespace.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; | ||
| const $empty = Symbol.for('react.memo_cache_sentinel'); | ||
| const c = typeof ((_b = React__namespace.__COMPILER_RUNTIME) === null || _b === void 0 ? void 0 : _b.c) === 'function' | ||
| ? | ||
| React__namespace.__COMPILER_RUNTIME.c | ||
| : function c(size) { | ||
| return React__namespace.useMemo(() => { | ||
| const $ = new Array(size); | ||
| for (let ii = 0; ii < size; ii++) { | ||
| $[ii] = $empty; | ||
| } | ||
| $[$empty] = true; | ||
| return $; | ||
| }, []); | ||
| }; | ||
| const LazyGuardDispatcher = {}; | ||
| // src/index.ts | ||
| var index_exports = {}; | ||
| __export(index_exports, { | ||
| $dispatcherGuard: () => $dispatcherGuard, | ||
| $makeReadOnly: () => $makeReadOnly, | ||
| $reset: () => $reset, | ||
| $structuralCheck: () => $structuralCheck, | ||
| c: () => c, | ||
| clearRenderCounterRegistry: () => clearRenderCounterRegistry, | ||
| renderCounterRegistry: () => renderCounterRegistry, | ||
| useRenderCounter: () => useRenderCounter | ||
| }); | ||
| module.exports = __toCommonJS(index_exports); | ||
| var React = __toESM(require("react")); | ||
| var { useRef, useEffect, isValidElement } = React; | ||
| var _a; | ||
| var ReactSecretInternals = ( | ||
| //@ts-ignore | ||
| (_a = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE) != null ? _a : React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED | ||
| ); | ||
| var $empty = Symbol.for("react.memo_cache_sentinel"); | ||
| var _a2; | ||
| var c = ( | ||
| // @ts-expect-error | ||
| typeof ((_a2 = React.__COMPILER_RUNTIME) == null ? void 0 : _a2.c) === "function" ? ( | ||
| // @ts-expect-error | ||
| React.__COMPILER_RUNTIME.c | ||
| ) : function c2(size) { | ||
| return React.useMemo(() => { | ||
| const $ = new Array(size); | ||
| for (let ii = 0; ii < size; ii++) { | ||
| $[ii] = $empty; | ||
| } | ||
| $[$empty] = true; | ||
| return $; | ||
| }, []); | ||
| } | ||
| ); | ||
| var LazyGuardDispatcher = {}; | ||
| [ | ||
| 'readContext', | ||
| 'useCallback', | ||
| 'useContext', | ||
| 'useEffect', | ||
| 'useImperativeHandle', | ||
| 'useInsertionEffect', | ||
| 'useLayoutEffect', | ||
| 'useMemo', | ||
| 'useReducer', | ||
| 'useRef', | ||
| 'useState', | ||
| 'useDebugValue', | ||
| 'useDeferredValue', | ||
| 'useTransition', | ||
| 'useMutableSource', | ||
| 'useSyncExternalStore', | ||
| 'useId', | ||
| 'unstable_isNewReconciler', | ||
| 'getCacheSignal', | ||
| 'getCacheForType', | ||
| 'useCacheRefresh', | ||
| ].forEach(name => { | ||
| LazyGuardDispatcher[name] = () => { | ||
| throw new Error(`[React] Unexpected React hook call (${name}) from a React compiled function. ` + | ||
| "Check that all hooks are called directly and named according to convention ('use[A-Z]') "); | ||
| }; | ||
| "readContext", | ||
| "useCallback", | ||
| "useContext", | ||
| "useEffect", | ||
| "useImperativeHandle", | ||
| "useInsertionEffect", | ||
| "useLayoutEffect", | ||
| "useMemo", | ||
| "useReducer", | ||
| "useRef", | ||
| "useState", | ||
| "useDebugValue", | ||
| "useDeferredValue", | ||
| "useTransition", | ||
| "useMutableSource", | ||
| "useSyncExternalStore", | ||
| "useId", | ||
| "unstable_isNewReconciler", | ||
| "getCacheSignal", | ||
| "getCacheForType", | ||
| "useCacheRefresh" | ||
| ].forEach((name) => { | ||
| LazyGuardDispatcher[name] = () => { | ||
| throw new Error( | ||
| `[React] Unexpected React hook call (${name}) from a React compiled function. Check that all hooks are called directly and named according to convention ('use[A-Z]') ` | ||
| ); | ||
| }; | ||
| }); | ||
| let originalDispatcher = null; | ||
| LazyGuardDispatcher['useMemoCache'] = (count) => { | ||
| if (originalDispatcher == null) { | ||
| throw new Error('React Compiler internal invariant violation: unexpected null dispatcher'); | ||
| } | ||
| else { | ||
| return originalDispatcher.useMemoCache(count); | ||
| } | ||
| var originalDispatcher = null; | ||
| LazyGuardDispatcher["useMemoCache"] = (count) => { | ||
| if (originalDispatcher == null) { | ||
| throw new Error( | ||
| "React Compiler internal invariant violation: unexpected null dispatcher" | ||
| ); | ||
| } else { | ||
| return originalDispatcher.useMemoCache(count); | ||
| } | ||
| }; | ||
| var GuardKind; | ||
| (function (GuardKind) { | ||
| GuardKind[GuardKind["PushGuardContext"] = 0] = "PushGuardContext"; | ||
| GuardKind[GuardKind["PopGuardContext"] = 1] = "PopGuardContext"; | ||
| GuardKind[GuardKind["PushExpectHook"] = 2] = "PushExpectHook"; | ||
| GuardKind[GuardKind["PopExpectHook"] = 3] = "PopExpectHook"; | ||
| })(GuardKind || (GuardKind = {})); | ||
| function setCurrent(newDispatcher) { | ||
| ReactSecretInternals.ReactCurrentDispatcher.current = newDispatcher; | ||
| return ReactSecretInternals.ReactCurrentDispatcher.current; | ||
| ReactSecretInternals.ReactCurrentDispatcher.current = newDispatcher; | ||
| return ReactSecretInternals.ReactCurrentDispatcher.current; | ||
| } | ||
| const guardFrames = []; | ||
| var guardFrames = []; | ||
| function $dispatcherGuard(kind) { | ||
| const curr = ReactSecretInternals.ReactCurrentDispatcher.current; | ||
| if (kind === GuardKind.PushGuardContext) { | ||
| guardFrames.push(curr); | ||
| if (guardFrames.length === 1) { | ||
| originalDispatcher = curr; | ||
| } | ||
| if (curr === LazyGuardDispatcher) { | ||
| throw new Error(`[React] Unexpected call to custom hook or component from a React compiled function. ` + | ||
| "Check that (1) all hooks are called directly and named according to convention ('use[A-Z]') " + | ||
| 'and (2) components are returned as JSX instead of being directly invoked.'); | ||
| } | ||
| setCurrent(LazyGuardDispatcher); | ||
| const curr = ReactSecretInternals.ReactCurrentDispatcher.current; | ||
| if (kind === 0 /* PushGuardContext */) { | ||
| guardFrames.push(curr); | ||
| if (guardFrames.length === 1) { | ||
| originalDispatcher = curr; | ||
| } | ||
| else if (kind === GuardKind.PopGuardContext) { | ||
| const lastFrame = guardFrames.pop(); | ||
| if (lastFrame == null) { | ||
| throw new Error('React Compiler internal error: unexpected null in guard stack'); | ||
| } | ||
| if (guardFrames.length === 0) { | ||
| originalDispatcher = null; | ||
| } | ||
| setCurrent(lastFrame); | ||
| if (curr === LazyGuardDispatcher) { | ||
| throw new Error( | ||
| `[React] Unexpected call to custom hook or component from a React compiled function. Check that (1) all hooks are called directly and named according to convention ('use[A-Z]') and (2) components are returned as JSX instead of being directly invoked.` | ||
| ); | ||
| } | ||
| else if (kind === GuardKind.PushExpectHook) { | ||
| guardFrames.push(curr); | ||
| setCurrent(originalDispatcher); | ||
| setCurrent(LazyGuardDispatcher); | ||
| } else if (kind === 1 /* PopGuardContext */) { | ||
| const lastFrame = guardFrames.pop(); | ||
| if (lastFrame == null) { | ||
| throw new Error( | ||
| "React Compiler internal error: unexpected null in guard stack" | ||
| ); | ||
| } | ||
| else if (kind === GuardKind.PopExpectHook) { | ||
| const lastFrame = guardFrames.pop(); | ||
| if (lastFrame == null) { | ||
| throw new Error('React Compiler internal error: unexpected null in guard stack'); | ||
| } | ||
| setCurrent(lastFrame); | ||
| if (guardFrames.length === 0) { | ||
| originalDispatcher = null; | ||
| } | ||
| else { | ||
| throw new Error('React Compiler internal error: unreachable block' + kind); | ||
| setCurrent(lastFrame); | ||
| } else if (kind === 2 /* PushExpectHook */) { | ||
| guardFrames.push(curr); | ||
| setCurrent(originalDispatcher); | ||
| } else if (kind === 3 /* PopExpectHook */) { | ||
| const lastFrame = guardFrames.pop(); | ||
| if (lastFrame == null) { | ||
| throw new Error( | ||
| "React Compiler internal error: unexpected null in guard stack" | ||
| ); | ||
| } | ||
| setCurrent(lastFrame); | ||
| } else { | ||
| throw new Error("React Compiler internal error: unreachable block" + kind); | ||
| } | ||
| } | ||
| function $reset($) { | ||
| for (let ii = 0; ii < $.length; ii++) { | ||
| $[ii] = $empty; | ||
| } | ||
| for (let ii = 0; ii < $.length; ii++) { | ||
| $[ii] = $empty; | ||
| } | ||
| } | ||
| function $makeReadOnly() { | ||
| throw new Error('TODO: implement $makeReadOnly in react-compiler-runtime'); | ||
| throw new Error("TODO: implement $makeReadOnly in react-compiler-runtime"); | ||
| } | ||
| const renderCounterRegistry = new Map(); | ||
| var renderCounterRegistry = /* @__PURE__ */ new Map(); | ||
| function clearRenderCounterRegistry() { | ||
| for (const counters of renderCounterRegistry.values()) { | ||
| counters.forEach(counter => { | ||
| counter.count = 0; | ||
| }); | ||
| } | ||
| for (const counters of renderCounterRegistry.values()) { | ||
| counters.forEach((counter) => { | ||
| counter.count = 0; | ||
| }); | ||
| } | ||
| } | ||
| function registerRenderCounter(name, val) { | ||
| let counters = renderCounterRegistry.get(name); | ||
| if (counters == null) { | ||
| counters = new Set(); | ||
| renderCounterRegistry.set(name, counters); | ||
| } | ||
| counters.add(val); | ||
| let counters = renderCounterRegistry.get(name); | ||
| if (counters == null) { | ||
| counters = /* @__PURE__ */ new Set(); | ||
| renderCounterRegistry.set(name, counters); | ||
| } | ||
| counters.add(val); | ||
| } | ||
| function removeRenderCounter(name, val) { | ||
| const counters = renderCounterRegistry.get(name); | ||
| if (counters == null) { | ||
| return; | ||
| } | ||
| counters.delete(val); | ||
| const counters = renderCounterRegistry.get(name); | ||
| if (counters == null) { | ||
| return; | ||
| } | ||
| counters.delete(val); | ||
| } | ||
| function useRenderCounter(name) { | ||
| const val = useRef(null); | ||
| if (val.current != null) { | ||
| val.current.count += 1; | ||
| const val = useRef(null); | ||
| if (val.current != null) { | ||
| val.current.count += 1; | ||
| } | ||
| useEffect(() => { | ||
| if (val.current == null) { | ||
| const counter = { count: 0 }; | ||
| registerRenderCounter(name, counter); | ||
| val.current = counter; | ||
| } | ||
| useEffect(() => { | ||
| if (val.current == null) { | ||
| const counter = { count: 0 }; | ||
| registerRenderCounter(name, counter); | ||
| val.current = counter; | ||
| } | ||
| return () => { | ||
| if (val.current !== null) { | ||
| removeRenderCounter(name, val.current); | ||
| } | ||
| }; | ||
| }); | ||
| return () => { | ||
| if (val.current !== null) { | ||
| removeRenderCounter(name, val.current); | ||
| } | ||
| }; | ||
| }); | ||
| } | ||
| const seenErrors = new Set(); | ||
| var seenErrors = /* @__PURE__ */ new Set(); | ||
| function $structuralCheck(oldValue, newValue, variableName, fnName, kind, loc) { | ||
| function error(l, r, path, depth) { | ||
| const str = `${fnName}:${loc} [${kind}] ${variableName}${path} changed from ${l} to ${r} at depth ${depth}`; | ||
| if (seenErrors.has(str)) { | ||
| return; | ||
| } | ||
| seenErrors.add(str); | ||
| console.error(str); | ||
| function error(l, r, path, depth) { | ||
| const str = `${fnName}:${loc} [${kind}] ${variableName}${path} changed from ${l} to ${r} at depth ${depth}`; | ||
| if (seenErrors.has(str)) { | ||
| return; | ||
| } | ||
| const depthLimit = 2; | ||
| function recur(oldValue, newValue, path, depth) { | ||
| if (depth > depthLimit) { | ||
| return; | ||
| seenErrors.add(str); | ||
| console.error(str); | ||
| } | ||
| const depthLimit = 2; | ||
| function recur(oldValue2, newValue2, path, depth) { | ||
| if (depth > depthLimit) { | ||
| return; | ||
| } else if (oldValue2 === newValue2) { | ||
| return; | ||
| } else if (typeof oldValue2 !== typeof newValue2) { | ||
| error(`type ${typeof oldValue2}`, `type ${typeof newValue2}`, path, depth); | ||
| } else if (typeof oldValue2 === "object") { | ||
| const oldArray = Array.isArray(oldValue2); | ||
| const newArray = Array.isArray(newValue2); | ||
| if (oldValue2 === null && newValue2 !== null) { | ||
| error("null", `type ${typeof newValue2}`, path, depth); | ||
| } else if (newValue2 === null) { | ||
| error(`type ${typeof oldValue2}`, "null", path, depth); | ||
| } else if (oldValue2 instanceof Map) { | ||
| if (!(newValue2 instanceof Map)) { | ||
| error(`Map instance`, `other value`, path, depth); | ||
| } else if (oldValue2.size !== newValue2.size) { | ||
| error( | ||
| `Map instance with size ${oldValue2.size}`, | ||
| `Map instance with size ${newValue2.size}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else { | ||
| for (const [k, v] of oldValue2) { | ||
| if (!newValue2.has(k)) { | ||
| error( | ||
| `Map instance with key ${k}`, | ||
| `Map instance without key ${k}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else { | ||
| recur(v, newValue2.get(k), `${path}.get(${k})`, depth + 1); | ||
| } | ||
| } | ||
| } | ||
| else if (oldValue === newValue) { | ||
| return; | ||
| } else if (newValue2 instanceof Map) { | ||
| error("other value", `Map instance`, path, depth); | ||
| } else if (oldValue2 instanceof Set) { | ||
| if (!(newValue2 instanceof Set)) { | ||
| error(`Set instance`, `other value`, path, depth); | ||
| } else if (oldValue2.size !== newValue2.size) { | ||
| error( | ||
| `Set instance with size ${oldValue2.size}`, | ||
| `Set instance with size ${newValue2.size}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else { | ||
| for (const v of newValue2) { | ||
| if (!oldValue2.has(v)) { | ||
| error( | ||
| `Set instance without element ${v}`, | ||
| `Set instance with element ${v}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } | ||
| } | ||
| } | ||
| else if (typeof oldValue !== typeof newValue) { | ||
| error(`type ${typeof oldValue}`, `type ${typeof newValue}`, path, depth); | ||
| } else if (newValue2 instanceof Set) { | ||
| error("other value", `Set instance`, path, depth); | ||
| } else if (oldArray || newArray) { | ||
| if (oldArray !== newArray) { | ||
| error( | ||
| `type ${oldArray ? "array" : "object"}`, | ||
| `type ${newArray ? "array" : "object"}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else if (oldValue2.length !== newValue2.length) { | ||
| error( | ||
| `array with length ${oldValue2.length}`, | ||
| `array with length ${newValue2.length}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else { | ||
| for (let ii = 0; ii < oldValue2.length; ii++) { | ||
| recur(oldValue2[ii], newValue2[ii], `${path}[${ii}]`, depth + 1); | ||
| } | ||
| } | ||
| else if (typeof oldValue === 'object') { | ||
| const oldArray = Array.isArray(oldValue); | ||
| const newArray = Array.isArray(newValue); | ||
| if (oldValue === null && newValue !== null) { | ||
| error('null', `type ${typeof newValue}`, path, depth); | ||
| } | ||
| else if (newValue === null) { | ||
| error(`type ${typeof oldValue}`, 'null', path, depth); | ||
| } | ||
| else if (oldValue instanceof Map) { | ||
| if (!(newValue instanceof Map)) { | ||
| error(`Map instance`, `other value`, path, depth); | ||
| } | ||
| else if (oldValue.size !== newValue.size) { | ||
| error(`Map instance with size ${oldValue.size}`, `Map instance with size ${newValue.size}`, path, depth); | ||
| } | ||
| else { | ||
| for (const [k, v] of oldValue) { | ||
| if (!newValue.has(k)) { | ||
| error(`Map instance with key ${k}`, `Map instance without key ${k}`, path, depth); | ||
| } | ||
| else { | ||
| recur(v, newValue.get(k), `${path}.get(${k})`, depth + 1); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| else if (newValue instanceof Map) { | ||
| error('other value', `Map instance`, path, depth); | ||
| } | ||
| else if (oldValue instanceof Set) { | ||
| if (!(newValue instanceof Set)) { | ||
| error(`Set instance`, `other value`, path, depth); | ||
| } | ||
| else if (oldValue.size !== newValue.size) { | ||
| error(`Set instance with size ${oldValue.size}`, `Set instance with size ${newValue.size}`, path, depth); | ||
| } | ||
| else { | ||
| for (const v of newValue) { | ||
| if (!oldValue.has(v)) { | ||
| error(`Set instance without element ${v}`, `Set instance with element ${v}`, path, depth); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| else if (newValue instanceof Set) { | ||
| error('other value', `Set instance`, path, depth); | ||
| } | ||
| else if (oldArray || newArray) { | ||
| if (oldArray !== newArray) { | ||
| error(`type ${oldArray ? 'array' : 'object'}`, `type ${newArray ? 'array' : 'object'}`, path, depth); | ||
| } | ||
| else if (oldValue.length !== newValue.length) { | ||
| error(`array with length ${oldValue.length}`, `array with length ${newValue.length}`, path, depth); | ||
| } | ||
| else { | ||
| for (let ii = 0; ii < oldValue.length; ii++) { | ||
| recur(oldValue[ii], newValue[ii], `${path}[${ii}]`, depth + 1); | ||
| } | ||
| } | ||
| } | ||
| else if (isValidElement(oldValue) || isValidElement(newValue)) { | ||
| if (isValidElement(oldValue) !== isValidElement(newValue)) { | ||
| error(`type ${isValidElement(oldValue) ? 'React element' : 'object'}`, `type ${isValidElement(newValue) ? 'React element' : 'object'}`, path, depth); | ||
| } | ||
| else if (oldValue.type !== newValue.type) { | ||
| error(`React element of type ${oldValue.type}`, `React element of type ${newValue.type}`, path, depth); | ||
| } | ||
| else { | ||
| recur(oldValue.props, newValue.props, `[props of ${path}]`, depth + 1); | ||
| } | ||
| } | ||
| else { | ||
| for (const key in newValue) { | ||
| if (!(key in oldValue)) { | ||
| error(`object without key ${key}`, `object with key ${key}`, path, depth); | ||
| } | ||
| } | ||
| for (const key in oldValue) { | ||
| if (!(key in newValue)) { | ||
| error(`object with key ${key}`, `object without key ${key}`, path, depth); | ||
| } | ||
| else { | ||
| recur(oldValue[key], newValue[key], `${path}.${key}`, depth + 1); | ||
| } | ||
| } | ||
| } | ||
| } else if (isValidElement(oldValue2) || isValidElement(newValue2)) { | ||
| if (isValidElement(oldValue2) !== isValidElement(newValue2)) { | ||
| error( | ||
| `type ${isValidElement(oldValue2) ? "React element" : "object"}`, | ||
| `type ${isValidElement(newValue2) ? "React element" : "object"}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else if (oldValue2.type !== newValue2.type) { | ||
| error( | ||
| `React element of type ${oldValue2.type}`, | ||
| `React element of type ${newValue2.type}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else { | ||
| recur( | ||
| oldValue2.props, | ||
| newValue2.props, | ||
| `[props of ${path}]`, | ||
| depth + 1 | ||
| ); | ||
| } | ||
| else if (typeof oldValue === 'function') { | ||
| return; | ||
| } else { | ||
| for (const key in newValue2) { | ||
| if (!(key in oldValue2)) { | ||
| error( | ||
| `object without key ${key}`, | ||
| `object with key ${key}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } | ||
| } | ||
| else if (isNaN(oldValue) || isNaN(newValue)) { | ||
| if (isNaN(oldValue) !== isNaN(newValue)) { | ||
| error(`${isNaN(oldValue) ? 'NaN' : 'non-NaN value'}`, `${isNaN(newValue) ? 'NaN' : 'non-NaN value'}`, path, depth); | ||
| } | ||
| for (const key in oldValue2) { | ||
| if (!(key in newValue2)) { | ||
| error( | ||
| `object with key ${key}`, | ||
| `object without key ${key}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } else { | ||
| recur(oldValue2[key], newValue2[key], `${path}.${key}`, depth + 1); | ||
| } | ||
| } | ||
| else if (oldValue !== newValue) { | ||
| error(oldValue, newValue, path, depth); | ||
| } | ||
| } | ||
| } else if (typeof oldValue2 === "function") { | ||
| return; | ||
| } else if (isNaN(oldValue2) || isNaN(newValue2)) { | ||
| if (isNaN(oldValue2) !== isNaN(newValue2)) { | ||
| error( | ||
| `${isNaN(oldValue2) ? "NaN" : "non-NaN value"}`, | ||
| `${isNaN(newValue2) ? "NaN" : "non-NaN value"}`, | ||
| path, | ||
| depth | ||
| ); | ||
| } | ||
| } else if (oldValue2 !== newValue2) { | ||
| error(oldValue2, newValue2, path, depth); | ||
| } | ||
| recur(oldValue, newValue, '', 0); | ||
| } | ||
| recur(oldValue, newValue, "", 0); | ||
| } | ||
| exports.$dispatcherGuard = $dispatcherGuard; | ||
| exports.$makeReadOnly = $makeReadOnly; | ||
| exports.$reset = $reset; | ||
| exports.$structuralCheck = $structuralCheck; | ||
| exports.c = c; | ||
| exports.clearRenderCounterRegistry = clearRenderCounterRegistry; | ||
| exports.renderCounterRegistry = renderCounterRegistry; | ||
| exports.useRenderCounter = useRenderCounter; | ||
| //# sourceMappingURL=index.js.map |
| { | ||
| "name": "react-compiler-runtime", | ||
| "version": "0.0.0-experimental-19cbb8f-20241107", | ||
| "version": "0.0.0-experimental-1a59184-20250113", | ||
| "description": "Runtime for React Compiler", | ||
| "license": "MIT", | ||
| "main": "dist/index.js", | ||
| "typings": "dist/index.d.ts", | ||
| "files": [ | ||
@@ -12,7 +13,8 @@ "dist", | ||
| "peerDependencies": { | ||
| "react": "^17.0.0 || ^18.0.0 || ^19.0.0" | ||
| "react": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^0.0.0-experimental" | ||
| }, | ||
| "scripts": { | ||
| "build": "rimraf dist && rollup --config --bundleConfigAsCjs", | ||
| "test": "echo 'no tests'" | ||
| "build": "rimraf dist && scripts/build.js", | ||
| "test": "echo 'no tests'", | ||
| "watch": "scripts/build.js --watch" | ||
| }, | ||
@@ -19,0 +21,0 @@ "repository": { |
@@ -8,4 +8,2 @@ /** | ||
| 'use no memo'; | ||
| import * as React from 'react'; | ||
@@ -12,0 +10,0 @@ |
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Lines of code
- increased by7.93%
789
Worsened metrics
- Total package byte prevSize
- decreased by-36.88%
45589
No dependency changes