react-compiler-runtime 0.0.0 → 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# react-compiler-runtime
+
+Backwards compatible shim for runtime APIs used by React Compiler. Primarily meant for React versions prior to 19, but it will also work on > 19.
+
+See also https://github.com/reactwg/react-compiler/discussions/6.

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+type MemoCache = Array<number | typeof $empty>;
+declare const $empty: unique symbol;
+declare const c: any;
+declare enum GuardKind {
+    PushGuardContext = 0,
+    PopGuardContext = 1,
+    PushExpectHook = 2,
+    PopExpectHook = 3
+}
+declare function $dispatcherGuard(kind: GuardKind): void;
+declare function $reset($: MemoCache): void;
+declare function $makeReadOnly(): void;
+declare const renderCounterRegistry: Map<string, Set<{
+    count: number;
+}>>;
+declare function clearRenderCounterRegistry(): void;
+declare function useRenderCounter(name: string): void;
+declare function $structuralCheck(oldValue: any, newValue: any, variableName: string, fnName: string, kind: string, loc: string): void;
+
+export { $dispatcherGuard, $makeReadOnly, $reset, $structuralCheck, c, clearRenderCounterRegistry, renderCounterRegistry, useRenderCounter };

package/dist/index.js

@@ -0,0 +1,385 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @lightSyntaxTransform
+ * @noflow
+ * @nolint
+ * @preventMunge
+ * @preserve-invariant-messages
+ */
+
+"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);
+
+// 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]') `
+    );
+  };
+});
+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);
+  }
+};
+function setCurrent(newDispatcher) {
+  ReactSecretInternals.ReactCurrentDispatcher.current = newDispatcher;
+  return ReactSecretInternals.ReactCurrentDispatcher.current;
+}
+var guardFrames = [];
+function $dispatcherGuard(kind) {
+  const curr = ReactSecretInternals.ReactCurrentDispatcher.current;
+  if (kind === 0 /* 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);
+  } else if (kind === 1 /* 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);
+  } 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;
+  }
+}
+function $makeReadOnly() {
+  throw new Error("TODO: implement $makeReadOnly in react-compiler-runtime");
+}
+var renderCounterRegistry = /* @__PURE__ */ new Map();
+function clearRenderCounterRegistry() {
+  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 = /* @__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);
+}
+function useRenderCounter(name) {
+  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;
+    }
+    return () => {
+      if (val.current !== null) {
+        removeRenderCounter(name, val.current);
+      }
+    };
+  });
+}
+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);
+  }
+  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 (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 (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 (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 {
+        for (const key in newValue2) {
+          if (!(key in oldValue2)) {
+            error(
+              `object without key ${key}`,
+              `object with key ${key}`,
+              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 (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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $dispatcherGuard,
+  $makeReadOnly,
+  $reset,
+  $structuralCheck,
+  c,
+  clearRenderCounterRegistry,
+  renderCounterRegistry,
+  useRenderCounter
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport * as React from 'react';\n\nconst {useRef, useEffect, isValidElement} = React;\nconst ReactSecretInternals =\n  //@ts-ignore\n  React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE ??\n  //@ts-ignore\n  React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n\ntype MemoCache = Array<number | typeof $empty>;\n\nconst $empty = Symbol.for('react.memo_cache_sentinel');\n\n// Re-export React.c if present, otherwise fallback to the userspace polyfill for versions of React\n// < 19.\nexport const c =\n  // @ts-expect-error\n  typeof React.__COMPILER_RUNTIME?.c === 'function'\n    ? // @ts-expect-error\n      React.__COMPILER_RUNTIME.c\n    : function c(size: number) {\n        return React.useMemo<Array<unknown>>(() => {\n          const $ = new Array(size);\n          for (let ii = 0; ii < size; ii++) {\n            $[ii] = $empty;\n          }\n          // This symbol is added to tell the react devtools that this array is from\n          // useMemoCache.\n          // @ts-ignore\n          $[$empty] = true;\n          return $;\n        }, []);\n      };\n\nconst LazyGuardDispatcher: {[key: string]: (...args: Array<any>) => any} = {};\n[\n  'readContext',\n  'useCallback',\n  'useContext',\n  'useEffect',\n  'useImperativeHandle',\n  'useInsertionEffect',\n  'useLayoutEffect',\n  'useMemo',\n  'useReducer',\n  'useRef',\n  'useState',\n  'useDebugValue',\n  'useDeferredValue',\n  'useTransition',\n  'useMutableSource',\n  'useSyncExternalStore',\n  'useId',\n  'unstable_isNewReconciler',\n  'getCacheSignal',\n  'getCacheForType',\n  'useCacheRefresh',\n].forEach(name => {\n  LazyGuardDispatcher[name] = () => {\n    throw new Error(\n      `[React] Unexpected React hook call (${name}) from a React compiled function. ` +\n        \"Check that all hooks are called directly and named according to convention ('use[A-Z]') \",\n    );\n  };\n});\n\nlet originalDispatcher: unknown = null;\n\n// Allow guards are not emitted for useMemoCache\nLazyGuardDispatcher['useMemoCache'] = (count: number) => {\n  if (originalDispatcher == null) {\n    throw new Error(\n      'React Compiler internal invariant violation: unexpected null dispatcher',\n    );\n  } else {\n    return (originalDispatcher as any).useMemoCache(count);\n  }\n};\n\nenum GuardKind {\n  PushGuardContext = 0,\n  PopGuardContext = 1,\n  PushExpectHook = 2,\n  PopExpectHook = 3,\n}\n\nfunction setCurrent(newDispatcher: any) {\n  ReactSecretInternals.ReactCurrentDispatcher.current = newDispatcher;\n  return ReactSecretInternals.ReactCurrentDispatcher.current;\n}\n\nconst guardFrames: Array<unknown> = [];\n\n/**\n * When `enableEmitHookGuards` is set, this does runtime validation\n * of the no-conditional-hook-calls rule.\n * As React Compiler needs to statically understand which calls to move out of\n * conditional branches (i.e. React Compiler cannot memoize the results of hook\n * calls), its understanding of \"the rules of React\" are more restrictive.\n * This validation throws on unsound inputs at runtime.\n *\n * Components should only be invoked through React as React Compiler could memoize\n * the call to AnotherComponent, introducing conditional hook calls in its\n * compiled output.\n * ```js\n * function Invalid(props) {\n *  const myJsx = AnotherComponent(props);\n *  return <div> { myJsx } </div>;\n * }\n *\n * Hooks must be named as hooks.\n * ```js\n * const renamedHook = useState;\n * function Invalid() {\n *   const [state, setState] = renamedHook(0);\n * }\n * ```\n *\n * Hooks must be directly called.\n * ```\n * function call(fn) {\n *  return fn();\n * }\n * function Invalid() {\n *   const result = call(useMyHook);\n * }\n * ```\n */\nexport function $dispatcherGuard(kind: GuardKind) {\n  const curr = ReactSecretInternals.ReactCurrentDispatcher.current;\n  if (kind === GuardKind.PushGuardContext) {\n    // Push before checking invariant or errors\n    guardFrames.push(curr);\n\n    if (guardFrames.length === 1) {\n      // save if we're the first guard on the stack\n      originalDispatcher = curr;\n    }\n\n    if (curr === LazyGuardDispatcher) {\n      throw new Error(\n        `[React] Unexpected call to custom hook or component from a React compiled function. ` +\n          \"Check that (1) all hooks are called directly and named according to convention ('use[A-Z]') \" +\n          'and (2) components are returned as JSX instead of being directly invoked.',\n      );\n    }\n    setCurrent(LazyGuardDispatcher);\n  } else if (kind === GuardKind.PopGuardContext) {\n    // Pop before checking invariant or errors\n    const lastFrame = guardFrames.pop();\n\n    if (lastFrame == null) {\n      throw new Error(\n        'React Compiler internal error: unexpected null in guard stack',\n      );\n    }\n    if (guardFrames.length === 0) {\n      originalDispatcher = null;\n    }\n    setCurrent(lastFrame);\n  } else if (kind === GuardKind.PushExpectHook) {\n    // ExpectHooks could be nested, so we save the current dispatcher\n    // for the matching PopExpectHook to restore.\n    guardFrames.push(curr);\n    setCurrent(originalDispatcher);\n  } else if (kind === GuardKind.PopExpectHook) {\n    const lastFrame = guardFrames.pop();\n    if (lastFrame == null) {\n      throw new Error(\n        'React Compiler internal error: unexpected null in guard stack',\n      );\n    }\n    setCurrent(lastFrame);\n  } else {\n    throw new Error('React Compiler internal error: unreachable block' + kind);\n  }\n}\n\nexport function $reset($: MemoCache) {\n  for (let ii = 0; ii < $.length; ii++) {\n    $[ii] = $empty;\n  }\n}\n\nexport function $makeReadOnly() {\n  throw new Error('TODO: implement $makeReadOnly in react-compiler-runtime');\n}\n\n/**\n * Instrumentation to count rerenders in React components\n */\nexport const renderCounterRegistry: Map<\n  string,\n  Set<{count: number}>\n> = new Map();\nexport function clearRenderCounterRegistry() {\n  for (const counters of renderCounterRegistry.values()) {\n    counters.forEach(counter => {\n      counter.count = 0;\n    });\n  }\n}\n\nfunction registerRenderCounter(name: string, val: {count: number}) {\n  let counters = renderCounterRegistry.get(name);\n  if (counters == null) {\n    counters = new Set();\n    renderCounterRegistry.set(name, counters);\n  }\n  counters.add(val);\n}\n\nfunction removeRenderCounter(name: string, val: {count: number}): void {\n  const counters = renderCounterRegistry.get(name);\n  if (counters == null) {\n    return;\n  }\n  counters.delete(val);\n}\n\nexport function useRenderCounter(name: string): void {\n  const val = useRef<{count: number}>(null);\n\n  if (val.current != null) {\n    val.current.count += 1;\n  }\n  useEffect(() => {\n    // Not counting initial render shouldn't be a problem\n    if (val.current == null) {\n      const counter = {count: 0};\n      registerRenderCounter(name, counter);\n      // @ts-ignore\n      val.current = counter;\n    }\n    return () => {\n      if (val.current !== null) {\n        removeRenderCounter(name, val.current);\n      }\n    };\n  });\n}\n\nconst seenErrors = new Set();\n\nexport function $structuralCheck(\n  oldValue: any,\n  newValue: any,\n  variableName: string,\n  fnName: string,\n  kind: string,\n  loc: string,\n): void {\n  function error(l: string, r: string, path: string, depth: number) {\n    const str = `${fnName}:${loc} [${kind}] ${variableName}${path} changed from ${l} to ${r} at depth ${depth}`;\n    if (seenErrors.has(str)) {\n      return;\n    }\n    seenErrors.add(str);\n    console.error(str);\n  }\n  const depthLimit = 2;\n  function recur(oldValue: any, newValue: any, path: string, depth: number) {\n    if (depth > depthLimit) {\n      return;\n    } else if (oldValue === newValue) {\n      return;\n    } else if (typeof oldValue !== typeof newValue) {\n      error(`type ${typeof oldValue}`, `type ${typeof newValue}`, path, depth);\n    } else if (typeof oldValue === 'object') {\n      const oldArray = Array.isArray(oldValue);\n      const newArray = Array.isArray(newValue);\n      if (oldValue === null && newValue !== null) {\n        error('null', `type ${typeof newValue}`, path, depth);\n      } else if (newValue === null) {\n        error(`type ${typeof oldValue}`, 'null', path, depth);\n      } else if (oldValue instanceof Map) {\n        if (!(newValue instanceof Map)) {\n          error(`Map instance`, `other value`, path, depth);\n        } else if (oldValue.size !== newValue.size) {\n          error(\n            `Map instance with size ${oldValue.size}`,\n            `Map instance with size ${newValue.size}`,\n            path,\n            depth,\n          );\n        } else {\n          for (const [k, v] of oldValue) {\n            if (!newValue.has(k)) {\n              error(\n                `Map instance with key ${k}`,\n                `Map instance without key ${k}`,\n                path,\n                depth,\n              );\n            } else {\n              recur(v, newValue.get(k), `${path}.get(${k})`, depth + 1);\n            }\n          }\n        }\n      } else if (newValue instanceof Map) {\n        error('other value', `Map instance`, path, depth);\n      } else if (oldValue instanceof Set) {\n        if (!(newValue instanceof Set)) {\n          error(`Set instance`, `other value`, path, depth);\n        } else if (oldValue.size !== newValue.size) {\n          error(\n            `Set instance with size ${oldValue.size}`,\n            `Set instance with size ${newValue.size}`,\n            path,\n            depth,\n          );\n        } else {\n          for (const v of newValue) {\n            if (!oldValue.has(v)) {\n              error(\n                `Set instance without element ${v}`,\n                `Set instance with element ${v}`,\n                path,\n                depth,\n              );\n            }\n          }\n        }\n      } else if (newValue instanceof Set) {\n        error('other value', `Set instance`, path, depth);\n      } else if (oldArray || newArray) {\n        if (oldArray !== newArray) {\n          error(\n            `type ${oldArray ? 'array' : 'object'}`,\n            `type ${newArray ? 'array' : 'object'}`,\n            path,\n            depth,\n          );\n        } else if (oldValue.length !== newValue.length) {\n          error(\n            `array with length ${oldValue.length}`,\n            `array with length ${newValue.length}`,\n            path,\n            depth,\n          );\n        } else {\n          for (let ii = 0; ii < oldValue.length; ii++) {\n            recur(oldValue[ii], newValue[ii], `${path}[${ii}]`, depth + 1);\n          }\n        }\n      } else if (isValidElement(oldValue) || isValidElement(newValue)) {\n        if (isValidElement(oldValue) !== isValidElement(newValue)) {\n          error(\n            `type ${isValidElement(oldValue) ? 'React element' : 'object'}`,\n            `type ${isValidElement(newValue) ? 'React element' : 'object'}`,\n            path,\n            depth,\n          );\n        } else if (oldValue.type !== newValue.type) {\n          error(\n            `React element of type ${oldValue.type}`,\n            `React element of type ${newValue.type}`,\n            path,\n            depth,\n          );\n        } else {\n          recur(\n            oldValue.props,\n            newValue.props,\n            `[props of ${path}]`,\n            depth + 1,\n          );\n        }\n      } else {\n        for (const key in newValue) {\n          if (!(key in oldValue)) {\n            error(\n              `object without key ${key}`,\n              `object with key ${key}`,\n              path,\n              depth,\n            );\n          }\n        }\n        for (const key in oldValue) {\n          if (!(key in newValue)) {\n            error(\n              `object with key ${key}`,\n              `object without key ${key}`,\n              path,\n              depth,\n            );\n          } else {\n            recur(oldValue[key], newValue[key], `${path}.${key}`, depth + 1);\n          }\n        }\n      }\n    } else if (typeof oldValue === 'function') {\n      // Bail on functions for now\n      return;\n    } else if (isNaN(oldValue) || isNaN(newValue)) {\n      if (isNaN(oldValue) !== isNaN(newValue)) {\n        error(\n          `${isNaN(oldValue) ? 'NaN' : 'non-NaN value'}`,\n          `${isNaN(newValue) ? 'NaN' : 'non-NaN value'}`,\n          path,\n          depth,\n        );\n      }\n    } else if (oldValue !== newValue) {\n      error(oldValue, newValue, path, depth);\n    }\n  }\n  recur(oldValue, newValue, '', 0);\n}\n"],"mappings":"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","names":["_a","c","oldValue","newValue"]}

package/package.json

@@ -1,11 +1,25 @@
 {
   "name": "react-compiler-runtime",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
+  "version": "1.0.0",
+  "description": "Runtime for React Compiler",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "peerDependencies": {
+    "react": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^0.0.0-experimental"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "rimraf dist && tsup",
+    "test": "echo 'no tests'",
+    "watch": "yarn build --watch"
   },
-  "author": "",
-  "license": "MIT"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/react.git",
+    "directory": "compiler/packages/react-compiler-runtime"
+  }
 }

package/src/index.ts

@@ -0,0 +1,417 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import * as React from 'react';
+
+const {useRef, useEffect, isValidElement} = React;
+const ReactSecretInternals =
+  //@ts-ignore
+  React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE ??
+  //@ts-ignore
+  React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+type MemoCache = Array<number | typeof $empty>;
+
+const $empty = Symbol.for('react.memo_cache_sentinel');
+
+// Re-export React.c if present, otherwise fallback to the userspace polyfill for versions of React
+// < 19.
+export const c =
+  // @ts-expect-error
+  typeof React.__COMPILER_RUNTIME?.c === 'function'
+    ? // @ts-expect-error
+      React.__COMPILER_RUNTIME.c
+    : function c(size: number) {
+        return React.useMemo<Array<unknown>>(() => {
+          const $ = new Array(size);
+          for (let ii = 0; ii < size; ii++) {
+            $[ii] = $empty;
+          }
+          // This symbol is added to tell the react devtools that this array is from
+          // useMemoCache.
+          // @ts-ignore
+          $[$empty] = true;
+          return $;
+        }, []);
+      };
+
+const LazyGuardDispatcher: {[key: string]: (...args: Array<any>) => any} = {};
+[
+  '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: unknown = null;
+
+// Allow guards are not emitted for useMemoCache
+LazyGuardDispatcher['useMemoCache'] = (count: number) => {
+  if (originalDispatcher == null) {
+    throw new Error(
+      'React Compiler internal invariant violation: unexpected null dispatcher',
+    );
+  } else {
+    return (originalDispatcher as any).useMemoCache(count);
+  }
+};
+
+enum GuardKind {
+  PushGuardContext = 0,
+  PopGuardContext = 1,
+  PushExpectHook = 2,
+  PopExpectHook = 3,
+}
+
+function setCurrent(newDispatcher: any) {
+  ReactSecretInternals.ReactCurrentDispatcher.current = newDispatcher;
+  return ReactSecretInternals.ReactCurrentDispatcher.current;
+}
+
+const guardFrames: Array<unknown> = [];
+
+/**
+ * When `enableEmitHookGuards` is set, this does runtime validation
+ * of the no-conditional-hook-calls rule.
+ * As React Compiler needs to statically understand which calls to move out of
+ * conditional branches (i.e. React Compiler cannot memoize the results of hook
+ * calls), its understanding of "the rules of React" are more restrictive.
+ * This validation throws on unsound inputs at runtime.
+ *
+ * Components should only be invoked through React as React Compiler could memoize
+ * the call to AnotherComponent, introducing conditional hook calls in its
+ * compiled output.
+ * ```js
+ * function Invalid(props) {
+ *  const myJsx = AnotherComponent(props);
+ *  return <div> { myJsx } </div>;
+ * }
+ *
+ * Hooks must be named as hooks.
+ * ```js
+ * const renamedHook = useState;
+ * function Invalid() {
+ *   const [state, setState] = renamedHook(0);
+ * }
+ * ```
+ *
+ * Hooks must be directly called.
+ * ```
+ * function call(fn) {
+ *  return fn();
+ * }
+ * function Invalid() {
+ *   const result = call(useMyHook);
+ * }
+ * ```
+ */
+export function $dispatcherGuard(kind: GuardKind) {
+  const curr = ReactSecretInternals.ReactCurrentDispatcher.current;
+  if (kind === GuardKind.PushGuardContext) {
+    // Push before checking invariant or errors
+    guardFrames.push(curr);
+
+    if (guardFrames.length === 1) {
+      // save if we're the first guard on the stack
+      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);
+  } else if (kind === GuardKind.PopGuardContext) {
+    // Pop before checking invariant or errors
+    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);
+  } else if (kind === GuardKind.PushExpectHook) {
+    // ExpectHooks could be nested, so we save the current dispatcher
+    // for the matching PopExpectHook to restore.
+    guardFrames.push(curr);
+    setCurrent(originalDispatcher);
+  } 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);
+  } else {
+    throw new Error('React Compiler internal error: unreachable block' + kind);
+  }
+}
+
+export function $reset($: MemoCache) {
+  for (let ii = 0; ii < $.length; ii++) {
+    $[ii] = $empty;
+  }
+}
+
+export function $makeReadOnly() {
+  throw new Error('TODO: implement $makeReadOnly in react-compiler-runtime');
+}
+
+/**
+ * Instrumentation to count rerenders in React components
+ */
+export const renderCounterRegistry: Map<
+  string,
+  Set<{count: number}>
+> = new Map();
+export function clearRenderCounterRegistry() {
+  for (const counters of renderCounterRegistry.values()) {
+    counters.forEach(counter => {
+      counter.count = 0;
+    });
+  }
+}
+
+function registerRenderCounter(name: string, val: {count: number}) {
+  let counters = renderCounterRegistry.get(name);
+  if (counters == null) {
+    counters = new Set();
+    renderCounterRegistry.set(name, counters);
+  }
+  counters.add(val);
+}
+
+function removeRenderCounter(name: string, val: {count: number}): void {
+  const counters = renderCounterRegistry.get(name);
+  if (counters == null) {
+    return;
+  }
+  counters.delete(val);
+}
+
+export function useRenderCounter(name: string): void {
+  const val = useRef<{count: number}>(null);
+
+  if (val.current != null) {
+    val.current.count += 1;
+  }
+  useEffect(() => {
+    // Not counting initial render shouldn't be a problem
+    if (val.current == null) {
+      const counter = {count: 0};
+      registerRenderCounter(name, counter);
+      // @ts-ignore
+      val.current = counter;
+    }
+    return () => {
+      if (val.current !== null) {
+        removeRenderCounter(name, val.current);
+      }
+    };
+  });
+}
+
+const seenErrors = new Set();
+
+export function $structuralCheck(
+  oldValue: any,
+  newValue: any,
+  variableName: string,
+  fnName: string,
+  kind: string,
+  loc: string,
+): void {
+  function error(l: string, r: string, path: string, depth: number) {
+    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);
+  }
+  const depthLimit = 2;
+  function recur(oldValue: any, newValue: any, path: string, depth: number) {
+    if (depth > depthLimit) {
+      return;
+    } else if (oldValue === newValue) {
+      return;
+    } else if (typeof oldValue !== typeof newValue) {
+      error(`type ${typeof oldValue}`, `type ${typeof newValue}`, path, depth);
+    } 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 (typeof oldValue === 'function') {
+      // Bail on functions for now
+      return;
+    } 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,
+        );
+      }
+    } else if (oldValue !== newValue) {
+      error(oldValue, newValue, path, depth);
+    }
+  }
+  recur(oldValue, newValue, '', 0);
+}