@barefootjs/test 0.24.1 → 0.25.0

package/dist/index.js

@@ -189766,7 +189766,8 @@ var ErrorCodes = {
   UNRECOGNIZED_REACTIVE_FACTORY: "BF110",
   REACTIVE_FACTORY_RENAME_UNSUPPORTED: "BF111",
   REACTIVE_FACTORY_MODULE_CAPTURE: "BF112",
-  REACTIVE_FACTORY_IMPORT_COLLISION: "BF113"
+  REACTIVE_FACTORY_IMPORT_COLLISION: "BF113",
+  REACTIVE_FACTORY_PARAM_SHADOWED: "BF114"
 };
 var errorMessages = {
   [ErrorCodes.MISSING_USE_CLIENT]: "'use client' directive required for components with createSignal or event handlers",
@@ -189793,7 +189794,8 @@ var errorMessages = {
   [ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY]: "Tuple destructuring of a non-reactive factory call. The compiler only recognizes createSignal / createMemo calls and same-file helpers that wrap them with a single `return [a, b]` exit.",
   [ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED]: "Reactive factory object return/destructure must use shorthand properties only. " + "Property renames (`{ lists: myLists }`), defaults, and rest elements are not " + "supported — destructure with the factory's own property names.",
   [ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE]: "Imported reactive factory references bindings from its own module scope, so its " + "body cannot be inlined into the component file. Move those helpers into the " + "component file, pass them to the factory as parameters, or define the factory " + "in the component file.",
-  [ErrorCodes.REACTIVE_FACTORY_IMPORT_COLLISION]: "Inlining an imported reactive factory requires re-importing one of its helper " + "imports into this file, but that name is already bound here to something else. " + "Rename the conflicting binding in this file, or alias the import in the factory's own file."
+  [ErrorCodes.REACTIVE_FACTORY_IMPORT_COLLISION]: "Inlining an imported reactive factory requires re-importing one of its helper " + "imports into this file, but that name is already bound here to something else. " + "Rename the conflicting binding in this file, or alias the import in the factory's own file.",
+  [ErrorCodes.REACTIVE_FACTORY_PARAM_SHADOWED]: "Reactive factory parameter is shadowed by a nested declaration inside the factory body, so argument substitution at the inline site would be ambiguous. Rename the inner binding so it does not collide with the parameter."
 };
 function createError(code2, loc, options) {
   if (code2 === undefined || !(code2 in errorMessages)) {
@@ -192293,6 +192295,7 @@ function collectEntryBindingNames(sf) {
   visit2(sf);
   return names;
 }
+var MAX_REEXPORT_HOPS = 1;
 function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
   const candidateCallees = new Set;
   function collectCandidates(node) {
@@ -192336,29 +192339,28 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
   const entryBindingNames = collectEntryBindingNames(entrySourceFile);
   const entryImportIndex = buildEntryImportIndex(entrySourceFile, filePath);
   const plannedInjections = new Map;
-  for (const { src, specs } of importsToCheck) {
-    const resolved = resolveRelativeImportToFile(src, filePath);
-    if (!resolved)
-      continue;
+  const helperCache = new Map;
+  function loadHelperFile(abs) {
+    const cached = helperCache.get(abs);
+    if (cached !== undefined)
+      return cached;
     let content;
     try {
-      content = fs.readFileSync(resolved, "utf8");
+      content = fs.readFileSync(abs, "utf8");
     } catch {
-      continue;
+      helperCache.set(abs, null);
+      return null;
     }
-    const alreadyKnown = (name) => result.factories.has(name) || result.declined.has(name) || result.reactiveShaped.has(name);
     const hasAnyPrimitiveText = [...REACTIVE_PRIMITIVES].some((p) => content.includes(p));
-    if (!hasAnyPrimitiveText) {
-      for (const spec of specs) {
-        if (!alreadyKnown(spec.local))
-          result.cleanFactoryImports.add(spec.local);
-      }
-      continue;
+    const hasReexportText = content.includes("export") && content.includes("from");
+    if (!hasAnyPrimitiveText && !hasReexportText) {
+      helperCache.set(abs, "clean");
+      return "clean";
     }
-    const helperSf = import_typescript8.default.createSourceFile(resolved + ".prescan", content, import_typescript8.default.ScriptTarget.Latest, true, import_typescript8.default.ScriptKind.TSX);
+    const sf = import_typescript8.default.createSourceFile(abs + ".prescan", content, import_typescript8.default.ScriptTarget.Latest, true, import_typescript8.default.ScriptKind.TSX);
     const localFns = new Map;
     const exportedFns = new Map;
-    for (const stmt of helperSf.statements) {
+    for (const stmt of sf.statements) {
       if (import_typescript8.default.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
         localFns.set(stmt.name.text, stmt);
         const hasExportModifier = stmt.modifiers?.some((m) => m.kind === import_typescript8.default.SyntaxKind.ExportKeyword) ?? false;
@@ -192368,27 +192370,89 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
         }
       }
     }
-    for (const stmt of helperSf.statements) {
-      if (import_typescript8.default.isExportDeclaration(stmt) && stmt.exportClause && import_typescript8.default.isNamedExports(stmt.exportClause) && !stmt.moduleSpecifier && !stmt.isTypeOnly) {
+    const reexports = new Map;
+    let hasStarReexport = false;
+    for (const stmt of sf.statements) {
+      if (!import_typescript8.default.isExportDeclaration(stmt) || stmt.isTypeOnly)
+        continue;
+      if (!stmt.moduleSpecifier) {
+        if (stmt.exportClause && import_typescript8.default.isNamedExports(stmt.exportClause)) {
+          for (const el of stmt.exportClause.elements) {
+            if (el.isTypeOnly)
+              continue;
+            const fn = localFns.get((el.propertyName ?? el.name).text);
+            if (fn)
+              exportedFns.set(el.name.text, fn);
+          }
+        }
+        continue;
+      }
+      if (!import_typescript8.default.isStringLiteral(stmt.moduleSpecifier))
+        continue;
+      if (stmt.exportClause && import_typescript8.default.isNamedExports(stmt.exportClause)) {
         for (const el of stmt.exportClause.elements) {
           if (el.isTypeOnly)
             continue;
-          const fn = localFns.get((el.propertyName ?? el.name).text);
-          if (fn)
-            exportedFns.set(el.name.text, fn);
+          reexports.set(el.name.text, {
+            source: stmt.moduleSpecifier.text,
+            innerName: (el.propertyName ?? el.name).text
+          });
         }
-      }
+      } else if (!stmt.exportClause) {
+        hasStarReexport = true;
+      }
+    }
+    const moduleBindings = collectHelperModuleValueBindings(sf);
+    const info = { sf, exportedFns, reexports, hasStarReexport, moduleBindings };
+    helperCache.set(abs, info);
+    return info;
+  }
+  function lookupExportedFactory(abs, exportedName, visited, hopsLeft) {
+    if (visited.has(abs))
+      return { kind: "unknown" };
+    visited.add(abs);
+    const file = loadHelperFile(abs);
+    if (file === null)
+      return { kind: "unknown" };
+    if (file === "clean")
+      return { kind: "clean" };
+    const fn = file.exportedFns.get(exportedName);
+    if (fn)
+      return { kind: "fn", fn, file, definingPath: abs };
+    const re = file.reexports.get(exportedName);
+    if (re) {
+      if (hopsLeft <= 0)
+        return { kind: "unknown" };
+      if (!re.source.startsWith("./") && !re.source.startsWith("../"))
+        return { kind: "unknown" };
+      const target = resolveRelativeImportToFile(re.source, abs);
+      if (!target)
+        return { kind: "unknown" };
+      return lookupExportedFactory(target, re.innerName, visited, hopsLeft - 1);
     }
-    const moduleBindings = collectHelperModuleValueBindings(helperSf);
+    if (file.hasStarReexport)
+      return { kind: "unknown" };
+    return { kind: "clean" };
+  }
+  for (const { src, specs } of importsToCheck) {
+    const resolved = resolveRelativeImportToFile(src, filePath);
+    if (!resolved)
+      continue;
+    const alreadyKnown = (name) => result.factories.has(name) || result.declined.has(name) || result.reactiveShaped.has(name);
     for (const spec of specs) {
       if (alreadyKnown(spec.local))
         continue;
-      const fn = exportedFns.get(spec.exported);
-      if (!fn) {
+      const found = lookupExportedFactory(resolved, spec.exported, new Set, MAX_REEXPORT_HOPS);
+      if (found.kind === "clean") {
         result.cleanFactoryImports.add(spec.local);
         continue;
       }
-      const det = detectReactiveFactory(fn, helperSf, resolved);
+      if (found.kind === "unknown")
+        continue;
+      const { fn, file, definingPath } = found;
+      const helperSf = file.sf;
+      const moduleBindings = file.moduleBindings;
+      const det = detectReactiveFactory(fn, helperSf, definingPath);
       if (!det) {
         result.cleanFactoryImports.add(spec.local);
         continue;
@@ -192417,7 +192481,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
             let specifier;
             let targetKey;
             if (ref.source.startsWith("./") || ref.source.startsWith("../")) {
-              const abs = resolveRelativeImportToFile(ref.source, resolved);
+              const abs = resolveRelativeImportToFile(ref.source, definingPath);
               if (!abs) {
                 declinedEntry = {
                   code: "BF112",
@@ -192455,7 +192519,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
           }
           for (const [name, id] of pending)
             plannedInjections.set(name, id);
-          det.info.sourceFilePath = resolved;
+          det.info.sourceFilePath = definingPath;
           if (required.length > 0)
             det.info.requiredImports = required;
           result.factories.set(spec.local, det.info);
@@ -192553,6 +192617,17 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   if (!hasReactiveCall)
     return null;
   const loc = getSourceLocation(node, sourceFile, filePath);
+  let totalReturnCount = 0;
+  function countReturns(n) {
+    if (import_typescript8.default.isFunctionLike(n))
+      return;
+    if (import_typescript8.default.isReturnStatement(n)) {
+      totalReturnCount++;
+      return;
+    }
+    import_typescript8.default.forEachChild(n, countReturns);
+  }
+  import_typescript8.default.forEachChild(node.body, countReturns);
   let returnExpr = null;
   let returnCount = 0;
   for (const stmt of node.body.statements) {
@@ -192570,7 +192645,7 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       expr = expr.expression;
     returnExpr = expr;
   }
-  if (returnCount !== 1 || !returnExpr)
+  if (totalReturnCount !== 1 || returnCount !== 1 || !returnExpr)
     return { kind: "reactive-shaped" };
   const returnTupleIdentifiers = [];
   let returnKind;
@@ -192604,6 +192679,14 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   } else {
     return { kind: "reactive-shaped" };
   }
+  const params = [];
+  for (const p of node.parameters) {
+    if (import_typescript8.default.isIdentifier(p.name)) {
+      params.push(p.name.text);
+      continue;
+    }
+    return { kind: "reactive-shaped" };
+  }
   const localBindings = [];
   for (const stmt of node.body.statements) {
     if (import_typescript8.default.isVariableStatement(stmt)) {
@@ -192614,15 +192697,95 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       localBindings.push(stmt.name.text);
     }
   }
-  const bodyStatements = node.body.statements.filter((s) => !import_typescript8.default.isReturnStatement(s)).map((s) => s.getText(sourceFile)).join(`
+  const relevantNames = new Set([...params, ...localBindings, ...returnTupleIdentifiers]);
+  const renameSites = [];
+  let shadowedParam = null;
+  function collectRenameSites(root, toBodyOffset) {
+    function push(id, form) {
+      renameSites.push({
+        name: id.text,
+        start: toBodyOffset(id.getStart(sourceFile)),
+        end: toBodyOffset(id.getEnd()),
+        form
+      });
+    }
+    function classify(id) {
+      if (!relevantNames.has(id.text))
+        return;
+      const p = id.parent;
+      if (import_typescript8.default.isPropertyAccessExpression(p) && p.name === id)
+        return;
+      if (import_typescript8.default.isPropertyAssignment(p) && p.name === id)
+        return;
+      if (import_typescript8.default.isBindingElement(p) && p.propertyName === id)
+        return;
+      if ((import_typescript8.default.isMethodDeclaration(p) || import_typescript8.default.isGetAccessorDeclaration(p) || import_typescript8.default.isSetAccessorDeclaration(p) || import_typescript8.default.isPropertyDeclaration(p) || import_typescript8.default.isEnumMember(p)) && p.name === id)
+        return;
+      if (import_typescript8.default.isJsxAttribute(p) && p.name === id)
+        return;
+      if (import_typescript8.default.isLabeledStatement(p) && p.label === id || (import_typescript8.default.isBreakStatement(p) || import_typescript8.default.isContinueStatement(p)) && p.label === id)
+        return;
+      if ((import_typescript8.default.isJsxOpeningElement(p) || import_typescript8.default.isJsxSelfClosingElement(p) || import_typescript8.default.isJsxClosingElement(p)) && p.tagName === id && /^[a-z]/.test(id.text))
+        return;
+      if (import_typescript8.default.isShorthandPropertyAssignment(p) && p.name === id) {
+        push(id, "shorthand");
+        return;
+      }
+      if (import_typescript8.default.isBindingElement(p) && p.name === id && !p.propertyName && import_typescript8.default.isObjectBindingPattern(p.parent)) {
+        if (params.includes(id.text))
+          shadowedParam = id.text;
+        push(id, "shorthand");
+        return;
+      }
+      const isDecl = (import_typescript8.default.isVariableDeclaration(p) || import_typescript8.default.isParameter(p) || import_typescript8.default.isBindingElement(p) || import_typescript8.default.isFunctionDeclaration(p) || import_typescript8.default.isFunctionExpression(p) || import_typescript8.default.isClassDeclaration(p) || import_typescript8.default.isClassExpression(p)) && p.name === id;
+      if (isDecl && params.includes(id.text))
+        shadowedParam = id.text;
+      push(id, "plain");
+    }
+    function visit2(n) {
+      if (import_typescript8.default.isTypeNode(n) || import_typescript8.default.isTypeParameterDeclaration(n) || import_typescript8.default.isTypeAliasDeclaration(n) || import_typescript8.default.isInterfaceDeclaration(n))
+        return;
+      if (import_typescript8.default.isIdentifier(n)) {
+        classify(n);
+        return;
+      }
+      import_typescript8.default.forEachChild(n, visit2);
+    }
+    visit2(root);
+  }
+  const keptStatements = node.body.statements.filter((s) => !import_typescript8.default.isReturnStatement(s));
+  const pieces = [];
+  let base = 0;
+  for (const stmt of keptStatements) {
+    const text = stmt.getText(sourceFile);
+    const stmtStart = stmt.getStart(sourceFile);
+    collectRenameSites(stmt, (pos) => pos - stmtStart + base);
+    pieces.push(text);
+    base += text.length + 1;
+  }
+  const bodyStatements = pieces.join(`
 `);
-  const params = [];
-  for (const p of node.parameters) {
-    if (import_typescript8.default.isIdentifier(p.name)) {
-      params.push(p.name.text);
-      continue;
+  if (shadowedParam !== null) {
+    return {
+      kind: "declined",
+      declined: {
+        code: "BF114",
+        detail: `parameter '${shadowedParam}' of '${node.name.text}' is shadowed by a nested declaration inside the factory body`,
+        loc
+      }
+    };
+  }
+  for (const site of renameSites) {
+    if (bodyStatements.slice(site.start, site.end) !== site.name) {
+      return {
+        kind: "declined",
+        declined: {
+          code: "BF111",
+          detail: `internal rename-site offset mismatch for '${site.name}' — this is a compiler bug, ` + `please report it`,
+          loc
+        }
+      };
     }
-    return { kind: "reactive-shaped" };
   }
   return {
     kind: "factory",
@@ -192632,7 +192795,8 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       returnTupleIdentifiers,
       returnKind,
       localBindings,
-      loc
+      loc,
+      renameSites
     }
   };
 }
@@ -192736,24 +192900,31 @@ function rewriteFactoryCallsInSource(source, prescan) {
     const argTexts = args.map((a) => a.getText(sourceFile));
     const thisCallIndex = callSiteIndex++;
     const suffix = `_bf${thisCallIndex}`;
-    let body = factory.bodySource;
-    const internalRenames = new Set(factory.localBindings);
-    for (const ex of excludeFromSuffixRename)
-      internalRenames.delete(ex);
-    for (const name of internalRenames) {
-      body = body.replace(new RegExp(`\\b${escapeRegex(name)}\\b`, "g"), name + suffix);
+    const renames = new Map;
+    for (const name of factory.localBindings) {
+      if (!excludeFromSuffixRename.has(name))
+        renames.set(name, name + suffix);
+    }
+    if (renameReturnToCallerNames) {
+      for (const [n, caller] of renameReturnToCallerNames) {
+        if (caller !== n)
+          renames.set(n, caller);
+      }
     }
     const atomicArg = /^(?:[\w$.]+|'[^'\\]*'|"[^"\\]*"|-?\d+(?:\.\d+)?)$/;
     for (let i2 = 0;i2 < factory.params.length; i2++) {
       const p = factory.params[i2];
-      const a = argTexts[i2] ?? "undefined";
-      const wrapped = atomicArg.test(a.trim()) ? a.trim() : `(${a})`;
-      body = body.replace(new RegExp(`\\b${escapeRegex(p)}\\b`, "g"), wrapped);
+      const a = (argTexts[i2] ?? "undefined").trim();
+      renames.set(p, atomicArg.test(a) ? a : `(${a})`);
     }
-    if (renameReturnToCallerNames) {
-      for (const [n, caller] of renameReturnToCallerNames) {
-        body = body.replace(new RegExp(`\\b${escapeRegex(n)}\\b`, "g"), caller);
-      }
+    let body = factory.bodySource;
+    for (let i2 = factory.renameSites.length - 1;i2 >= 0; i2--) {
+      const site = factory.renameSites[i2];
+      const repl = renames.get(site.name);
+      if (repl === undefined)
+        continue;
+      const text = site.form === "shorthand" ? `${site.name}: ${repl}` : repl;
+      body = body.slice(0, site.start) + text + body.slice(site.end);
     }
     edits.push({
       start: stmt.getStart(sourceFile),
@@ -192818,9 +192989,6 @@ function isPascalCaseComponentFn(node) {
   }
   return false;
 }
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function declinedFactoryMessage(callee, d) {
   if (d.code === "BF112") {
     return `Reactive factory '${callee}' references ${d.detail} from its own module ` + `scope and cannot be inlined. Move the referenced helper(s) into this file, ` + `pass them as factory arguments, or inline the factory here.`;
@@ -192836,6 +193004,8 @@ function declinedFactoryErrorCode(code2) {
       return ErrorCodes.REACTIVE_FACTORY_MODULE_CAPTURE;
     case "BF113":
       return ErrorCodes.REACTIVE_FACTORY_IMPORT_COLLISION;
+    case "BF114":
+      return ErrorCodes.REACTIVE_FACTORY_PARAM_SHADOWED;
     default:
       return ErrorCodes.REACTIVE_FACTORY_RENAME_UNSUPPORTED;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "Test utilities for BarefootJS - IR-based component testing without a browser",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "directory": "packages/test"
   },
   "dependencies": {
-    "@barefootjs/jsx": "0.24.1"
+    "@barefootjs/jsx": "0.25.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0"