@barefootjs/cli 0.24.1 → 0.25.0

package/dist/index.js

@@ -5453,7 +5453,8 @@ var init_errors = __esm({
       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"
     };
     errorMessages = {
       [ErrorCodes.MISSING_USE_CLIENT]: "'use client' directive required for components with createSignal or event handlers",
@@ -5488,7 +5489,8 @@ var init_errors = __esm({
       [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 \u2014 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."
     };
     InternalInvariantError = class extends Error {
       constructor(message) {
@@ -7832,33 +7834,27 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
   const entryBindingNames = collectEntryBindingNames(entrySourceFile);
   const entryImportIndex = buildEntryImportIndex(entrySourceFile, filePath);
   const plannedInjections = /* @__PURE__ */ new Map();
-  for (const { src, specs } of importsToCheck) {
-    const resolved = resolveRelativeImportToFile(src, filePath);
-    if (!resolved) continue;
+  const helperCache = /* @__PURE__ */ new Map();
+  function loadHelperFile(abs) {
+    const cached = helperCache.get(abs);
+    if (cached !== void 0) return cached;
     let content2;
     try {
-      content2 = fs.readFileSync(resolved, "utf8");
+      content2 = fs.readFileSync(abs, "utf8");
     } catch {
-      continue;
+      helperCache.set(abs, null);
+      return null;
     }
-    const alreadyKnown = (name2) => result2.factories.has(name2) || result2.declined.has(name2) || result2.reactiveShaped.has(name2);
     const hasAnyPrimitiveText = [...REACTIVE_PRIMITIVES].some((p) => content2.includes(p));
-    if (!hasAnyPrimitiveText) {
-      for (const spec of specs) {
-        if (!alreadyKnown(spec.local)) result2.cleanFactoryImports.add(spec.local);
-      }
-      continue;
+    const hasReexportText = content2.includes("export") && content2.includes("from");
+    if (!hasAnyPrimitiveText && !hasReexportText) {
+      helperCache.set(abs, "clean");
+      return "clean";
     }
-    const helperSf = ts8.createSourceFile(
-      resolved + ".prescan",
-      content2,
-      ts8.ScriptTarget.Latest,
-      true,
-      ts8.ScriptKind.TSX
-    );
+    const sf = ts8.createSourceFile(abs + ".prescan", content2, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TSX);
     const localFns = /* @__PURE__ */ new Map();
     const exportedFns = /* @__PURE__ */ new Map();
-    for (const stmt of helperSf.statements) {
+    for (const stmt of sf.statements) {
       if (ts8.isFunctionDeclaration(stmt) && stmt.name && stmt.body) {
         localFns.set(stmt.name.text, stmt);
         const hasExportModifier = stmt.modifiers?.some((m) => m.kind === ts8.SyntaxKind.ExportKeyword) ?? false;
@@ -7868,24 +7864,73 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
         }
       }
     }
-    for (const stmt of helperSf.statements) {
-      if (ts8.isExportDeclaration(stmt) && stmt.exportClause && ts8.isNamedExports(stmt.exportClause) && !stmt.moduleSpecifier && !stmt.isTypeOnly) {
+    const reexports = /* @__PURE__ */ new Map();
+    let hasStarReexport = false;
+    for (const stmt of sf.statements) {
+      if (!ts8.isExportDeclaration(stmt) || stmt.isTypeOnly) continue;
+      if (!stmt.moduleSpecifier) {
+        if (stmt.exportClause && ts8.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 (!ts8.isStringLiteral(stmt.moduleSpecifier)) continue;
+      if (stmt.exportClause && ts8.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
+          });
         }
-      }
-    }
-    const moduleBindings = collectHelperModuleValueBindings(helperSf);
+      } 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 target2 = resolveRelativeImportToFile(re.source, abs);
+      if (!target2) return { kind: "unknown" };
+      return lookupExportedFactory(target2, re.innerName, visited, hopsLeft - 1);
+    }
+    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 = (name2) => result2.factories.has(name2) || result2.declined.has(name2) || result2.reactiveShaped.has(name2);
     for (const spec of specs) {
       if (alreadyKnown(spec.local)) continue;
-      const fn = exportedFns.get(spec.exported);
-      if (!fn) {
+      const found = lookupExportedFactory(resolved, spec.exported, /* @__PURE__ */ new Set(), MAX_REEXPORT_HOPS);
+      if (found.kind === "clean") {
         result2.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) {
         result2.cleanFactoryImports.add(spec.local);
         continue;
@@ -7914,7 +7959,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
             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",
@@ -7951,7 +7996,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result2) {
             break;
           }
           for (const [name2, id2] of pending) plannedInjections.set(name2, id2);
-          det.info.sourceFilePath = resolved;
+          det.info.sourceFilePath = definingPath;
           if (required.length > 0) det.info.requiredImports = required;
           result2.factories.set(spec.local, det.info);
           break;
@@ -8033,6 +8078,16 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   checkForReactive(node.body);
   if (!hasReactiveCall) return null;
   const loc = getSourceLocation(node, sourceFile, filePath);
+  let totalReturnCount = 0;
+  function countReturns(n) {
+    if (ts8.isFunctionLike(n)) return;
+    if (ts8.isReturnStatement(n)) {
+      totalReturnCount++;
+      return;
+    }
+    ts8.forEachChild(n, countReturns);
+  }
+  ts8.forEachChild(node.body, countReturns);
   let returnExpr = null;
   let returnCount = 0;
   for (const stmt of node.body.statements) {
@@ -8045,7 +8100,7 @@ function detectReactiveFactory(node, sourceFile, filePath) {
     if (ts8.isTypeAssertionExpression(expr)) expr = expr.expression;
     returnExpr = expr;
   }
-  if (returnCount !== 1 || !returnExpr) return { kind: "reactive-shaped" };
+  if (totalReturnCount !== 1 || returnCount !== 1 || !returnExpr) return { kind: "reactive-shaped" };
   const returnTupleIdentifiers = [];
   let returnKind;
   if (ts8.isArrayLiteralExpression(returnExpr)) {
@@ -8075,6 +8130,14 @@ function detectReactiveFactory(node, sourceFile, filePath) {
   } else {
     return { kind: "reactive-shaped" };
   }
+  const params = [];
+  for (const p of node.parameters) {
+    if (ts8.isIdentifier(p.name)) {
+      params.push(p.name.text);
+      continue;
+    }
+    return { kind: "reactive-shaped" };
+  }
   const localBindings = [];
   for (const stmt of node.body.statements) {
     if (ts8.isVariableStatement(stmt)) {
@@ -8085,14 +8148,83 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       localBindings.push(stmt.name.text);
     }
   }
-  const bodyStatements = node.body.statements.filter((s) => !ts8.isReturnStatement(s)).map((s) => s.getText(sourceFile)).join("\n");
-  const params = [];
-  for (const p of node.parameters) {
-    if (ts8.isIdentifier(p.name)) {
-      params.push(p.name.text);
-      continue;
+  const relevantNames = /* @__PURE__ */ new Set([...params, ...localBindings, ...returnTupleIdentifiers]);
+  const renameSites = [];
+  let shadowedParam = null;
+  function collectRenameSites(root2, toBodyOffset) {
+    function push(id2, form) {
+      renameSites.push({
+        name: id2.text,
+        start: toBodyOffset(id2.getStart(sourceFile)),
+        end: toBodyOffset(id2.getEnd()),
+        form
+      });
+    }
+    function classify3(id2) {
+      if (!relevantNames.has(id2.text)) return;
+      const p = id2.parent;
+      if (ts8.isPropertyAccessExpression(p) && p.name === id2) return;
+      if (ts8.isPropertyAssignment(p) && p.name === id2) return;
+      if (ts8.isBindingElement(p) && p.propertyName === id2) return;
+      if ((ts8.isMethodDeclaration(p) || ts8.isGetAccessorDeclaration(p) || ts8.isSetAccessorDeclaration(p) || ts8.isPropertyDeclaration(p) || ts8.isEnumMember(p)) && p.name === id2) return;
+      if (ts8.isJsxAttribute(p) && p.name === id2) return;
+      if (ts8.isLabeledStatement(p) && p.label === id2 || (ts8.isBreakStatement(p) || ts8.isContinueStatement(p)) && p.label === id2) return;
+      if ((ts8.isJsxOpeningElement(p) || ts8.isJsxSelfClosingElement(p) || ts8.isJsxClosingElement(p)) && p.tagName === id2 && /^[a-z]/.test(id2.text)) return;
+      if (ts8.isShorthandPropertyAssignment(p) && p.name === id2) {
+        push(id2, "shorthand");
+        return;
+      }
+      if (ts8.isBindingElement(p) && p.name === id2 && !p.propertyName && ts8.isObjectBindingPattern(p.parent)) {
+        if (params.includes(id2.text)) shadowedParam = id2.text;
+        push(id2, "shorthand");
+        return;
+      }
+      const isDecl = (ts8.isVariableDeclaration(p) || ts8.isParameter(p) || ts8.isBindingElement(p) || ts8.isFunctionDeclaration(p) || ts8.isFunctionExpression(p) || ts8.isClassDeclaration(p) || ts8.isClassExpression(p)) && p.name === id2;
+      if (isDecl && params.includes(id2.text)) shadowedParam = id2.text;
+      push(id2, "plain");
+    }
+    function visit3(n) {
+      if (ts8.isTypeNode(n) || ts8.isTypeParameterDeclaration(n) || ts8.isTypeAliasDeclaration(n) || ts8.isInterfaceDeclaration(n)) return;
+      if (ts8.isIdentifier(n)) {
+        classify3(n);
+        return;
+      }
+      ts8.forEachChild(n, visit3);
+    }
+    visit3(root2);
+  }
+  const keptStatements = node.body.statements.filter((s) => !ts8.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("\n");
+  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}' \u2014 this is a compiler bug, please report it`,
+          loc
+        }
+      };
     }
-    return { kind: "reactive-shaped" };
   }
   return {
     kind: "factory",
@@ -8102,7 +8234,8 @@ function detectReactiveFactory(node, sourceFile, filePath) {
       returnTupleIdentifiers,
       returnKind,
       localBindings,
-      loc
+      loc,
+      renameSites
     }
   };
 }
@@ -8189,23 +8322,28 @@ function rewriteFactoryCallsInSource(source, prescan) {
     const argTexts = args2.map((a) => a.getText(sourceFile));
     const thisCallIndex = callSiteIndex++;
     const suffix = `_bf${thisCallIndex}`;
-    let body2 = factory.bodySource;
-    const internalRenames = new Set(factory.localBindings);
-    for (const ex of excludeFromSuffixRename) internalRenames.delete(ex);
-    for (const name2 of internalRenames) {
-      body2 = body2.replace(new RegExp(`\\b${escapeRegex(name2)}\\b`, "g"), name2 + suffix);
+    const renames = /* @__PURE__ */ new Map();
+    for (const name2 of factory.localBindings) {
+      if (!excludeFromSuffixRename.has(name2)) renames.set(name2, name2 + suffix);
+    }
+    if (renameReturnToCallerNames) {
+      for (const [n, caller] of renameReturnToCallerNames) {
+        if (caller !== n) renames.set(n, caller);
+      }
     }
     const atomicArg = /^(?:[\w$.]+|'[^'\\]*'|"[^"\\]*"|-?\d+(?:\.\d+)?)$/;
     for (let i = 0; i < factory.params.length; i++) {
       const p = factory.params[i];
-      const a = argTexts[i] ?? "undefined";
-      const wrapped = atomicArg.test(a.trim()) ? a.trim() : `(${a})`;
-      body2 = body2.replace(new RegExp(`\\b${escapeRegex(p)}\\b`, "g"), wrapped);
+      const a = (argTexts[i] ?? "undefined").trim();
+      renames.set(p, atomicArg.test(a) ? a : `(${a})`);
     }
-    if (renameReturnToCallerNames) {
-      for (const [n, caller] of renameReturnToCallerNames) {
-        body2 = body2.replace(new RegExp(`\\b${escapeRegex(n)}\\b`, "g"), caller);
-      }
+    let body2 = factory.bodySource;
+    for (let i = factory.renameSites.length - 1; i >= 0; i--) {
+      const site = factory.renameSites[i];
+      const repl = renames.get(site.name);
+      if (repl === void 0) continue;
+      const text = site.form === "shorthand" ? `${site.name}: ${repl}` : repl;
+      body2 = body2.slice(0, site.start) + text + body2.slice(site.end);
     }
     edits.push({
       start: stmt.getStart(sourceFile),
@@ -8265,9 +8403,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.`;
@@ -8283,6 +8418,8 @@ function declinedFactoryErrorCode(code) {
       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;
   }
@@ -8403,7 +8540,7 @@ function validateObjectFactoryDestructure(ctx2, pattern, callee, loc) {
     }));
   }
 }
-var REACTIVE_BRAND_PACKAGES, PRIMITIVE_CANONICAL_NAMES, ENV_SIGNAL_FACTORIES, CLIENT_EXPORTS, CLIENT_DIRECTIVE_INTERIOR_RE, BLOCK_COMMENT_RE, CLIENT_EXPORT_SIGNAL_RE, CLIENT_EXPORT_MEMO_RE, BROWSER_ONLY_CLIENT_APIS, REACTIVE_PRIMITIVES;
+var REACTIVE_BRAND_PACKAGES, PRIMITIVE_CANONICAL_NAMES, ENV_SIGNAL_FACTORIES, CLIENT_EXPORTS, CLIENT_DIRECTIVE_INTERIOR_RE, BLOCK_COMMENT_RE, CLIENT_EXPORT_SIGNAL_RE, CLIENT_EXPORT_MEMO_RE, BROWSER_ONLY_CLIENT_APIS, REACTIVE_PRIMITIVES, MAX_REEXPORT_HOPS;
 var init_analyzer = __esm({
   "../jsx/src/analyzer.ts"() {
     "use strict";
@@ -8493,6 +8630,7 @@ var init_analyzer = __esm({
       "onMount",
       "onCleanup"
     ]);
+    MAX_REEXPORT_HOPS = 1;
   }
 });
 
@@ -34818,7 +34956,7 @@ function patchBlock(css, openRe, overrides) {
   let block = css.slice(blockStart, blockEnd);
   const toAppend = [];
   for (const [name2, value2] of Object.entries(overrides)) {
-    const re = new RegExp(`(${escapeRegex2(name2)}\\s*:\\s*)[^;]+(;)`);
+    const re = new RegExp(`(${escapeRegex(name2)}\\s*:\\s*)[^;]+(;)`);
     if (re.test(block)) {
       block = block.replace(re, `$1${value2}$2`);
     } else {
@@ -34836,7 +34974,7 @@ ${lines}
   }
   return css.slice(0, blockStart) + block + css.slice(blockEnd);
 }
-function escapeRegex2(s) {
+function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function applyTokenOverrides(tokensJsonPath, config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/cli",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "CLI for agent-driven UI component discovery and scaffolding",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,11 +29,11 @@
   "dependencies": {
     "esbuild": "^0.25.0",
     "typescript": "^5.0.0",
-    "@barefootjs/client": "0.24.1",
-    "@barefootjs/shared": "0.24.1"
+    "@barefootjs/client": "0.25.0",
+    "@barefootjs/shared": "0.25.0"
   },
   "devDependencies": {
-    "@barefootjs/jsx": "0.24.1",
+    "@barefootjs/jsx": "0.25.0",
     "@types/node": "^22.0.0",
     "@happy-dom/global-registrator": "^20.0.11",
     "happy-dom": "^20.0.11"