babel-plugin-react-compiler 0.0.0-experimental-bc310bf-20250507 → 0.0.0-experimental-ec81157-20250508

package/dist/index.d.ts

@@ -532,9 +532,6 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     } | null | undefined;
 }>;
 type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
-declare function parseConfigPragmaForTests(pragma: string, defaults: {
-    compilationMode: CompilationMode;
-}): PluginOptions;
 type PartialEnvironmentConfig = Partial<EnvironmentConfig>;
 type ReactFunctionType = 'Component' | 'Hook' | 'Other';
 declare class Environment {
@@ -1558,10 +1555,10 @@ type PluginOptions = {
     panicThreshold: PanicThresholdOptions;
     noEmit: boolean;
     compilationMode: CompilationMode;
-    eslintSuppressionRules?: Array<string> | null | undefined;
+    eslintSuppressionRules: Array<string> | null | undefined;
     flowSuppressions: boolean;
     ignoreUseNoForget: boolean;
-    sources?: Array<string> | ((filename: string) => boolean) | null;
+    sources: Array<string> | ((filename: string) => boolean) | null;
     enableReanimatedCheck: boolean;
     target: CompilerReactTarget;
 };
@@ -1668,6 +1665,10 @@ declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPa
 
 declare function runBabelPluginReactCompiler(text: string, file: string, language: 'flow' | 'typescript', options: Partial<PluginOptions> | null, includeAst?: boolean): BabelCore.BabelFileResult;
 
+declare function parseConfigPragmaForTests(pragma: string, defaults: {
+    compilationMode: CompilationMode;
+}): PluginOptions;
+
 declare function BabelPluginReactCompiler(_babel: typeof BabelCore): BabelCore.PluginObj;
 
 declare global {

package/dist/index.js

@@ -63752,7 +63752,7 @@ __export(index_exports, {
   ErrorSeverity: () => ErrorSeverity,
   OPT_IN_DIRECTIVES: () => OPT_IN_DIRECTIVES,
   OPT_OUT_DIRECTIVES: () => OPT_OUT_DIRECTIVES,
-  ProgramContext: () => ProgramContext2,
+  ProgramContext: () => ProgramContext,
   ValueKind: () => ValueKind,
   compile: () => compileFn,
   compileProgram: () => compileProgram,
@@ -78177,158 +78177,6 @@ var EnvironmentConfigSchema = z.object({
    */
   lowerContextAccess: ExternalFunctionSchema.nullable().default(null)
 });
-var testComplexConfigDefaults = {
-  validateNoCapitalizedCalls: [],
-  enableChangeDetectionForDebugging: {
-    source: "react-compiler-runtime",
-    importSpecifierName: "$structuralCheck"
-  },
-  enableEmitFreeze: {
-    source: "react-compiler-runtime",
-    importSpecifierName: "makeReadOnly"
-  },
-  enableEmitInstrumentForget: {
-    fn: {
-      source: "react-compiler-runtime",
-      importSpecifierName: "useRenderCounter"
-    },
-    gating: {
-      source: "react-compiler-runtime",
-      importSpecifierName: "shouldInstrument"
-    },
-    globalGating: "DEV"
-  },
-  enableEmitHookGuards: {
-    source: "react-compiler-runtime",
-    importSpecifierName: "$dispatcherGuard"
-  },
-  inlineJsxTransform: {
-    elementSymbol: "react.transitional.element",
-    globalDevVar: "DEV"
-  },
-  lowerContextAccess: {
-    source: "react-compiler-runtime",
-    importSpecifierName: "useContext_withSelector"
-  },
-  inferEffectDependencies: [
-    {
-      function: {
-        source: "react",
-        importSpecifierName: "useEffect"
-      },
-      numRequiredArgs: 1
-    },
-    {
-      function: {
-        source: "shared-runtime",
-        importSpecifierName: "useSpecialEffect"
-      },
-      numRequiredArgs: 2
-    },
-    {
-      function: {
-        source: "useEffectWrapper",
-        importSpecifierName: "default"
-      },
-      numRequiredArgs: 1
-    }
-  ]
-};
-function parseConfigPragmaEnvironmentForTest(pragma) {
-  const maybeConfig = {};
-  const defaultConfig = EnvironmentConfigSchema.parse({});
-  for (const token2 of pragma.split(" ")) {
-    if (!token2.startsWith("@")) {
-      continue;
-    }
-    const keyVal = token2.slice(1);
-    let [key2, val = void 0] = keyVal.split(":");
-    const isSet = val === void 0 || val === "true";
-    if (isSet && key2 in testComplexConfigDefaults) {
-      maybeConfig[key2] = testComplexConfigDefaults[key2];
-      continue;
-    }
-    if (key2 === "customMacros" && val) {
-      const valSplit = val.split(".");
-      if (valSplit.length > 0) {
-        const props = [];
-        for (const elt of valSplit.slice(1)) {
-          if (elt === "*") {
-            props.push({ type: "wildcard" });
-          } else if (elt.length > 0) {
-            props.push({ type: "name", name: elt });
-          }
-        }
-        maybeConfig[key2] = [[valSplit[0], props]];
-      }
-      continue;
-    }
-    if (key2 !== "enableResetCacheOnSourceFileChanges" && typeof defaultConfig[key2] !== "boolean") {
-      continue;
-    }
-    if (val === void 0 || val === "true") {
-      maybeConfig[key2] = true;
-    } else {
-      maybeConfig[key2] = false;
-    }
-  }
-  const config = EnvironmentConfigSchema.safeParse(maybeConfig);
-  if (config.success) {
-    if (config.data.enableResetCacheOnSourceFileChanges == null) {
-      config.data.enableResetCacheOnSourceFileChanges = false;
-    }
-    return config.data;
-  }
-  CompilerError.invariant(false, {
-    reason: "Internal error, could not parse config from pragma string",
-    description: `${fromZodError(config.error)}`,
-    loc: null,
-    suggestions: null
-  });
-}
-function parseConfigPragmaForTests(pragma, defaults) {
-  const environment = parseConfigPragmaEnvironmentForTest(pragma);
-  let compilationMode = defaults.compilationMode;
-  let panicThreshold = "all_errors";
-  let noEmit = defaultOptions.noEmit;
-  for (const token2 of pragma.split(" ")) {
-    if (!token2.startsWith("@")) {
-      continue;
-    }
-    switch (token2) {
-      case "@compilationMode(annotation)": {
-        compilationMode = "annotation";
-        break;
-      }
-      case "@compilationMode(infer)": {
-        compilationMode = "infer";
-        break;
-      }
-      case "@compilationMode(all)": {
-        compilationMode = "all";
-        break;
-      }
-      case "@compilationMode(syntax)": {
-        compilationMode = "syntax";
-        break;
-      }
-      case "@panicThreshold(none)": {
-        panicThreshold = "none";
-        break;
-      }
-      case "@noEmit": {
-        noEmit = true;
-        break;
-      }
-    }
-  }
-  return parsePluginOptions({
-    environment,
-    compilationMode,
-    panicThreshold,
-    noEmit
-  });
-}
 var _globals, _shapes, _moduleTypes, _nextIdentifer, _nextBlock, _nextScope, _scope, _outlinedFunctions, _contextIdentifiers, _hoistedIdentifiers, _Environment_instances, resolveModuleType_fn, isKnownReactModule_fn, getCustomHookType_fn;
 var Environment = class {
   constructor(scope, fnType, compilerMode, config, contextIdentifiers, logger, filename, code, programContext) {
@@ -80141,6 +79989,19 @@ function evaluateInstruction(constants, instr) {
           }
           return null;
         }
+        case "-": {
+          const operand = read2(constants, value.value);
+          if (operand !== null && operand.kind === "Primitive" && typeof operand.value === "number") {
+            const result = {
+              kind: "Primitive",
+              value: operand.value * -1,
+              loc: value.loc
+            };
+            instr.value = result;
+            return result;
+          }
+          return null;
+        }
         default:
           return null;
       }
@@ -80297,6 +80158,49 @@ function evaluateInstruction(constants, instr) {
       }
       return null;
     }
+    case "TemplateLiteral": {
+      if (value.subexprs.length === 0) {
+        const result2 = {
+          kind: "Primitive",
+          value: value.quasis.map((q) => q.cooked).join(""),
+          loc: value.loc
+        };
+        instr.value = result2;
+        return result2;
+      }
+      if (value.subexprs.length !== value.quasis.length - 1) {
+        return null;
+      }
+      if (value.quasis.some((q) => q.cooked === void 0)) {
+        return null;
+      }
+      let quasiIndex = 0;
+      let resultString = value.quasis[quasiIndex].cooked;
+      ++quasiIndex;
+      for (const subExpr of value.subexprs) {
+        const subExprValue = read2(constants, subExpr);
+        if (!subExprValue || subExprValue.kind !== "Primitive") {
+          return null;
+        }
+        const expressionValue = subExprValue.value;
+        if (typeof expressionValue !== "number" && typeof expressionValue !== "string" && typeof expressionValue !== "boolean" && !(typeof expressionValue === "object" && expressionValue === null)) {
+          return null;
+        }
+        const suffix = value.quasis[quasiIndex].cooked;
+        ++quasiIndex;
+        if (suffix === void 0) {
+          return null;
+        }
+        resultString = resultString.concat(expressionValue, suffix);
+      }
+      const result = {
+        kind: "Primitive",
+        value: resultString,
+        loc: value.loc
+      };
+      instr.value = result;
+      return result;
+    }
     case "LoadLocal": {
       const placeValue = read2(constants, value.place);
       if (placeValue !== null) {
@@ -97322,7 +97226,7 @@ function compileProgram(program, pass) {
     handleError(restrictedImportsErr, pass, null);
     return null;
   }
-  const programContext = new ProgramContext2(
+  const programContext = new ProgramContext(
     program,
     pass.opts.target,
     environment.hookPattern
@@ -97895,7 +97799,7 @@ function validateRestrictedImports(path, { validateBlocklistedImports }) {
     return null;
   }
 }
-var ProgramContext2 = class {
+var ProgramContext = class {
   constructor(program, reactRuntimeModule, hookPattern) {
     // known generated or referenced identifiers in the program
     this.knownReferencedNames = /* @__PURE__ */ new Set();
@@ -98490,6 +98394,176 @@ function runBabelPluginReactCompiler(text, file, language, options, includeAst =
   return result;
 }
 
+// src/Utils/TestUtils.ts
+function tryParseTestPragmaValue(val) {
+  try {
+    let parsedVal;
+    const stringMatch = /^"([^"]*)"$/.exec(val);
+    if (stringMatch && stringMatch.length > 1) {
+      parsedVal = stringMatch[1];
+    } else {
+      parsedVal = JSON.parse(val);
+    }
+    return Ok(parsedVal);
+  } catch (e) {
+    return Err(e);
+  }
+}
+var testComplexConfigDefaults = {
+  validateNoCapitalizedCalls: [],
+  enableChangeDetectionForDebugging: {
+    source: "react-compiler-runtime",
+    importSpecifierName: "$structuralCheck"
+  },
+  enableEmitFreeze: {
+    source: "react-compiler-runtime",
+    importSpecifierName: "makeReadOnly"
+  },
+  enableEmitInstrumentForget: {
+    fn: {
+      source: "react-compiler-runtime",
+      importSpecifierName: "useRenderCounter"
+    },
+    gating: {
+      source: "react-compiler-runtime",
+      importSpecifierName: "shouldInstrument"
+    },
+    globalGating: "DEV"
+  },
+  enableEmitHookGuards: {
+    source: "react-compiler-runtime",
+    importSpecifierName: "$dispatcherGuard"
+  },
+  inlineJsxTransform: {
+    elementSymbol: "react.transitional.element",
+    globalDevVar: "DEV"
+  },
+  lowerContextAccess: {
+    source: "react-compiler-runtime",
+    importSpecifierName: "useContext_withSelector"
+  },
+  inferEffectDependencies: [
+    {
+      function: {
+        source: "react",
+        importSpecifierName: "useEffect"
+      },
+      numRequiredArgs: 1
+    },
+    {
+      function: {
+        source: "shared-runtime",
+        importSpecifierName: "useSpecialEffect"
+      },
+      numRequiredArgs: 2
+    },
+    {
+      function: {
+        source: "useEffectWrapper",
+        importSpecifierName: "default"
+      },
+      numRequiredArgs: 1
+    }
+  ]
+};
+function parseConfigPragmaEnvironmentForTest(pragma) {
+  const maybeConfig = {};
+  for (const token2 of pragma.split(" ")) {
+    if (!token2.startsWith("@")) {
+      continue;
+    }
+    const keyVal = token2.slice(1);
+    const valIdx = keyVal.indexOf(":");
+    const key2 = valIdx === -1 ? keyVal : keyVal.slice(0, valIdx);
+    const val = valIdx === -1 ? void 0 : keyVal.slice(valIdx + 1);
+    const isSet = val === void 0 || val === "true";
+    if (!hasOwnProperty2(EnvironmentConfigSchema.shape, key2)) {
+      continue;
+    }
+    if (isSet && key2 in testComplexConfigDefaults) {
+      maybeConfig[key2] = testComplexConfigDefaults[key2];
+    } else if (isSet) {
+      maybeConfig[key2] = true;
+    } else if (val === "false") {
+      maybeConfig[key2] = false;
+    } else if (val) {
+      const parsedVal = tryParseTestPragmaValue(val).unwrap();
+      if (key2 === "customMacros" && typeof parsedVal === "string") {
+        const valSplit = parsedVal.split(".");
+        const props = [];
+        for (const elt of valSplit.slice(1)) {
+          if (elt === "*") {
+            props.push({ type: "wildcard" });
+          } else if (elt.length > 0) {
+            props.push({ type: "name", name: elt });
+          }
+        }
+        maybeConfig[key2] = [[valSplit[0], props]];
+        continue;
+      }
+      maybeConfig[key2] = parsedVal;
+    }
+  }
+  const config = EnvironmentConfigSchema.safeParse(maybeConfig);
+  if (config.success) {
+    if (config.data.enableResetCacheOnSourceFileChanges == null) {
+      config.data.enableResetCacheOnSourceFileChanges = false;
+    }
+    return config.data;
+  }
+  CompilerError.invariant(false, {
+    reason: "Internal error, could not parse config from pragma string",
+    description: `${fromZodError(config.error)}`,
+    loc: null,
+    suggestions: null
+  });
+}
+var testComplexPluginOptionDefaults = {
+  gating: {
+    source: "ReactForgetFeatureFlag",
+    importSpecifierName: "isForgetEnabled_Fixtures"
+  }
+};
+function parseConfigPragmaForTests(pragma, defaults) {
+  const environment = parseConfigPragmaEnvironmentForTest(pragma);
+  const options = __spreadProps(__spreadValues({}, defaultOptions), {
+    panicThreshold: "all_errors",
+    compilationMode: defaults.compilationMode,
+    environment
+  });
+  for (const token2 of pragma.split(" ")) {
+    if (!token2.startsWith("@")) {
+      continue;
+    }
+    const keyVal = token2.slice(1);
+    const idx = keyVal.indexOf(":");
+    const key2 = idx === -1 ? keyVal : keyVal.slice(0, idx);
+    const val = idx === -1 ? void 0 : keyVal.slice(idx + 1);
+    if (!hasOwnProperty2(defaultOptions, key2)) {
+      continue;
+    }
+    const isSet = val === void 0 || val === "true";
+    if (isSet && key2 in testComplexPluginOptionDefaults) {
+      options[key2] = testComplexPluginOptionDefaults[key2];
+    } else if (isSet) {
+      options[key2] = true;
+    } else if (val === "false") {
+      options[key2] = false;
+    } else if (val != null) {
+      const parsedVal = tryParseTestPragmaValue(val).unwrap();
+      if (key2 === "target" && parsedVal === "donotuse_meta_internal") {
+        options[key2] = {
+          kind: parsedVal,
+          runtimeModule: "react"
+        };
+      } else {
+        options[key2] = parsedVal;
+      }
+    }
+  }
+  return parsePluginOptions(options);
+}
+
 // src/index.ts
 var index_default = BabelPluginReactCompiler;
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-bc310bf-20250507",
+  "version": "0.0.0-experimental-ec81157-20250508",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",