@barefootjs/cli 0.31.2 → 0.31.3

package/dist/index.js

@@ -6164,7 +6164,8 @@ function visit(node, ctx2, targetComponentName, namedExports) {
   if (!ctx2.componentNode) {
     collectAmbientGlobals(node, ctx2);
   }
-  if (ts9.isVariableStatement(node) && !ctx2.componentNode) {
+  const isDeclareStatement = ts9.isVariableStatement(node) && (node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.DeclareKeyword) ?? false);
+  if (ts9.isVariableStatement(node) && !ctx2.componentNode && !isDeclareStatement) {
     const isExported = node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ExportKeyword) ?? false;
     const isLet = (node.declarationList.flags & ts9.NodeFlags.Let) !== 0;
     const isModuleClientDirective = hasLeadingClientDirectiveOnStatement(node, ctx2.sourceFile);
@@ -6180,7 +6181,7 @@ function visit(node, ctx2, targetComponentName, namedExports) {
         }
         continue;
       }
-      if (ts9.isIdentifier(decl.name) && decl.initializer && !isArrowComponentFunction(decl)) {
+      if (ts9.isIdentifier(decl.name) && (decl.initializer || isLet) && !isArrowComponentFunction(decl)) {
         collectConstant(decl, ctx2, true, isLet ? "let" : "const", isExported);
       }
     }
@@ -7590,6 +7591,7 @@ function collectConstant(node, ctx2, _isModule, declarationKind = "const", isExp
     value: value2,
     parsed,
     typedValue: typedValue !== value2 ? typedValue : void 0,
+    typeAnnotation: node.type ? node.type.getText(ctx2.sourceFile) : void 0,
     valueBranches,
     declarationKind,
     isExported,
@@ -9982,6 +9984,176 @@ var init_to_locale_date_lowering = __esm({
   }
 });
 
+// ../jsx/src/scope/binding-scope.ts
+var BindingScope;
+var init_binding_scope = __esm({
+  "../jsx/src/scope/binding-scope.ts"() {
+    "use strict";
+    BindingScope = class _BindingScope {
+      constructor(frames2) {
+        this.frames = frames2;
+      }
+      static EMPTY = new _BindingScope([]);
+      /**
+       * Child scope with a new `'loop-row'` frame for one loop's per-item
+       * bindings. Parent (`this`) is not mutated; the returned scope is a
+       * NEW object with `frames = [newFrame, ...this.frames]`.
+       *
+       * Binding semantics mirror `jsx-to-ir.ts`'s `ctx.loopParams` add site
+       * EXACTLY (verified against lines ~4320-4345 and the matching delete
+       * site ~4695-4710 of `packages/jsx/src/jsx-to-ir.ts`):
+       *
+       *   - When `loop.paramBindings` is non-empty (a destructured callback
+       *     param, e.g. `.map(({ id, name }) => ...)`), each `paramBindings[i].name`
+       *     is bound with source `'destructure'` and the raw `param` text
+       *     (which for a destructured callback holds the ORIGINAL pattern
+       *     source, e.g. `"{ id, name }"`, not a usable identifier) is NOT
+       *     bound. This matches `jsx-to-ir.ts`:
+       *       `if (paramBindings) { for (const b of paramBindings) ctx.loopParams.add(b.name) }`
+       *     — the `else` branch (`ctx.loopParams.add(param)`) is skipped
+       *     entirely when `paramBindings` is present.
+       *   - Otherwise (a plain identifier param, e.g. `.map(item => ...)`),
+       *     `param` itself is bound with source `'item'`.
+       *   - `index` (the second callback param, e.g. `.map((item, i) => ...)`)
+       *     is bound with source `'index'` when non-null/non-undefined.
+       *   - Every name in `preamble.declaredNames` (a `.map()` callback's
+       *     pre-return `const`/`let`/`function` locals, #2447) is bound with
+       *     source `'preamble'`.
+       *
+       *   NOTE on a sibling mechanism this method does NOT mirror:
+       *   `adapters/loop-bound-names.ts`'s `collectLoopBoundNames` adds BOTH
+       *   `node.param` AND every `paramBindings[i].name` unconditionally
+       *   (never skipping `param` in the destructured case) — a deliberately
+       *   coarser, over-inclusive collection used only to subtract names from
+       *   a flat string-typing Set (safe to over-exclude there). This method
+       *   follows the precise `jsx-to-ir.ts` `ctx.loopParams` semantics, since
+       *   that is the mechanism actually doing scope-shadowed name RESOLUTION
+       *   (the behavior `BindingScope` replaces), not coarse exclusion.
+       */
+      enterLoopRow(loop) {
+        const bindings = /* @__PURE__ */ new Map();
+        if (loop.paramBindings && loop.paramBindings.length > 0) {
+          for (const b of loop.paramBindings) bindings.set(b.name, { source: "destructure" });
+        } else {
+          bindings.set(loop.param, { source: "item" });
+        }
+        if (loop.index != null) bindings.set(loop.index, { source: "index" });
+        for (const name2 of loop.preamble?.declaredNames ?? []) bindings.set(name2, { source: "preamble" });
+        const frame = { kind: "loop-row", bindings };
+        return new _BindingScope([frame, ...this.frames]);
+      }
+      /**
+       * Child scope with a new `'callback'` frame binding `params` (a filter
+       * predicate's `x`, a sort comparator's `(a, b)`, or a nested arrow's
+       * parameter list) with source `'param'`. Parent is not mutated.
+       */
+      enterCallback(params) {
+        const bindings = /* @__PURE__ */ new Map();
+        for (const name2 of params) bindings.set(name2, { source: "param" });
+        const frame = { kind: "callback", bindings };
+        return new _BindingScope([frame, ...this.frames]);
+      }
+      /** Innermost-first membership check across every frame in the stack. */
+      isBound(name2) {
+        for (const frame of this.frames) {
+          if (frame.bindings.has(name2)) return true;
+        }
+        return false;
+      }
+      /**
+       * Resolves `name` against the frame stack innermost-first. `depth 0`
+       * means the innermost (most recently entered) frame; `null` when `name`
+       * is not bound in any frame.
+       */
+      lookup(name2) {
+        for (let depth = 0; depth < this.frames.length; depth++) {
+          const frame = this.frames[depth];
+          const binding = frame.bindings.get(name2);
+          if (binding) return { depth, frame, binding };
+        }
+        return null;
+      }
+      /**
+       * Union of every frame's bound names (every `ScopeBindingSource`), for
+       * migration interop with legacy `Set<string>`-shaped consumers (e.g.
+       * `collectLoopBoundNames`'s return type) as later stages migrate them
+       * onto `BindingScope`.
+       *
+       * This is the SHADOW-GUARD query — see {@link valueBoundNames} for the
+       * other consumer class and why the two must not be conflated.
+       */
+      boundNames() {
+        if (this.boundNamesCache) return this.boundNamesCache;
+        const names = /* @__PURE__ */ new Set();
+        for (const frame of this.frames) {
+          for (const name2 of frame.bindings.keys()) names.add(name2);
+        }
+        this.boundNamesCache = names;
+        return names;
+      }
+      // Both name queries are hot (shadow guards, slot/reactivity classifiers,
+      // binding-env memo keying) and the scope is immutable, so each computes
+      // once per instance. Callers receive the cached set as ReadonlySet —
+      // never mutate it.
+      boundNamesCache;
+      valueBoundNamesCache;
+      /**
+       * Union of names bound via `'item'`/`'index'`/`'destructure'` sources
+       * only — the loop row's own per-item identity — excluding `'preamble'`
+       * (a `.map()` callback's pre-return `const`/`let`/`function` locals,
+       * #2447) and `'param'` (an `enterCallback` frame's filter/sort/nested-
+       * arrow parameters).
+       *
+       * `BindingScope` has exactly two consumer classes, and conflating them
+       * is the #2482 Stage 1a Commit 2 regression this split exists to
+       * prevent (a `ctx.scope`-wide preamble merge flipped `tag-cloud` and
+       * `preamble-cells` conformance fixtures before this method existed):
+       *
+       *   - SHADOW GUARDS (`tryResolveTemplateSpanFromConst`,
+       *     `tryResolveIdentifierAsTemplateLiteral`, `rewriteBarePropRefs`
+       *     in `jsx-to-ir.ts`) ask "is this name resolved to SOMETHING in
+       *     this scope, so an outer const/prop of the same name must not be
+       *     substituted here at this transform position" — every source
+       *     qualifies, including a preamble local shadowing a module const.
+       *     These call `isBound` / `boundNames()`.
+       *   - REACTIVITY / SLOT-ID CLASSIFIERS (`referencesLoopParam`,
+       *     `hasReactiveAttributes`, and the `BindingEnvironment.loopParams`
+       *     feed built from `makeBindingEnv`, all in `jsx-to-ir.ts`) ask
+       *     "does this expression read a value that changes per row and so
+       *     needs its own patchable slot" — a preamble local already gets
+       *     ITS OWN dedicated slot/region-patch machinery
+       *     (`preambleRegions` / `markPreambleAttrSlots`, #2447), so folding
+       *     it into this classification double-counts it. Worse: widening a
+       *     text child's `reactive` flag this way is read by
+       *     `hasDynamicContent` to decide whether the loop ROW's own root
+       *     element needs a slot — an unrelated, narrower decision that must
+       *     not move just because a preamble local is now scope-visible.
+       *     These call `valueBoundNames()`.
+       */
+      valueBoundNames() {
+        if (this.valueBoundNamesCache) return this.valueBoundNamesCache;
+        const names = /* @__PURE__ */ new Set();
+        for (const frame of this.frames) {
+          for (const [name2, binding] of frame.bindings) {
+            if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
+              names.add(name2);
+            }
+          }
+        }
+        this.valueBoundNamesCache = names;
+        return names;
+      }
+      /**
+       * Drop-in for `resolveStaticLoopSource`'s `opts.isNameShadowed`
+       * (`packages/jsx/src/static-literal.ts:112-128`).
+       */
+      asShadowPredicate() {
+        return (name2) => this.isBound(name2);
+      }
+    };
+  }
+});
+
 // ../jsx/src/jsx-to-ir.ts
 import ts12 from "typescript";
 function hasLeadingClientDirective(expr, sourceFile) {
@@ -10151,8 +10323,9 @@ function rewriteBarePropRefs2(text, expr, ctx2) {
   const dateLowered = lowerToLocaleDateCalls(lowerDateCalls(text, expr, ctx2), expr, ctx2);
   let propNames = getDestructuredPropNames(ctx2);
   if (!propNames) return dateLowered === text ? void 0 : dateLowered;
-  if (ctx2.loopParams.size > 0) {
-    const filtered = new Set([...propNames].filter((n) => !ctx2.loopParams.has(n)));
+  const shadowingNames = ctx2.scope.boundNames();
+  if (shadowingNames.size > 0) {
+    const filtered = new Set([...propNames].filter((n) => !shadowingNames.has(n)));
     if (filtered.size === 0) return dateLowered === text ? void 0 : dateLowered;
     propNames = filtered;
   }
@@ -10220,7 +10393,7 @@ function createTransformContext(analyzer) {
     spreadIdCounter: 0,
     isRoot: true,
     insideComponentChildren: false,
-    loopParams: /* @__PURE__ */ new Set(),
+    scope: BindingScope.EMPTY,
     loopDepth: 0,
     patterns: {
       signals: analyzer.signals.map((s) => ({
@@ -10289,7 +10462,8 @@ function generateSpreadSlotId(ctx2) {
   return `Spread_${ctx2.spreadIdCounter++}`;
 }
 function makeBindingEnv(ctx2) {
-  const loopKey = ctx2.loopParams.size === 0 ? "" : Array.from(ctx2.loopParams).sort().join("\0");
+  const boundNames = ctx2.scope.valueBoundNames();
+  const loopKey = boundNames.size === 0 ? "" : Array.from(boundNames).sort().join("\0");
   if (ctx2._bindingEnv && ctx2._bindingEnvLoopKey === loopKey) {
     return ctx2._bindingEnv;
   }
@@ -10304,9 +10478,11 @@ function makeBindingEnv(ctx2) {
     localFunctions: a.localFunctions,
     imports: a.imports,
     ambientGlobals: a.ambientGlobals,
-    // Snapshot — the env must observe a stable view even if `ctx.loopParams`
-    // is later mutated by an enclosing visitor frame.
-    loopParams: new Set(ctx2.loopParams),
+    // `valueBoundNames()` returns a per-instance set that is never
+    // mutated (cached on the immutable `BindingScope`) — a stable
+    // snapshot even if `ctx.scope` is later reassigned by an enclosing
+    // visitor frame, which swaps the instance rather than mutating it.
+    loopParams: boundNames,
     checker: a.checker
   };
   ctx2._bindingEnv = env;
@@ -11003,7 +11179,8 @@ function transformExpressionInner(expr, ctx2, node, isClientOnly) {
     freeRefs
   };
   const reactive = isReactiveExpression(exprText, ctx2, expr) || isReactiveOrigin(origin);
-  const refsLoopParam = ctx2.loopParams.size > 0 && Array.from(ctx2.loopParams).some((p) => new RegExp(`\\b${p}\\b`).test(exprText));
+  const scopeValueNames = ctx2.scope.valueBoundNames();
+  const refsLoopParam = scopeValueNames.size > 0 && Array.from(scopeValueNames).some((p) => new RegExp(`\\b${p}\\b`).test(exprText));
   const callsReactive = exprCallsReactiveGetters(expr, ctx2);
   const hasCalls = exprHasFunctionCalls(expr);
   const needsSlot = reactive || isClientOnly || refsLoopParam || callsReactive || hasCalls;
@@ -12055,7 +12232,7 @@ function extractItemConditionalKey(cond) {
   return a ?? b;
 }
 function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
-  const isNested = ctx2.loopParams.size > 0;
+  const isNested = ctx2.scope.valueBoundNames().size > 0;
   const diagCountAtEntry = ctx2.analyzer.errors.length;
   const depth = ctx2.loopDepth;
   const propAccess = node.expression;
@@ -12250,12 +12427,8 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         indexType = secondParam.type.getText(ctx2.sourceFile);
       }
     }
-    if (paramBindings) {
-      for (const b of paramBindings) ctx2.loopParams.add(b.name);
-    } else {
-      ctx2.loopParams.add(param);
-    }
-    if (index) ctx2.loopParams.add(index);
+    const savedScope = ctx2.scope;
+    ctx2.scope = ctx2.scope.enterLoopRow({ param, index, paramBindings });
     ctx2.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
       if (!ts12.isBinaryExpression(expr)) return;
@@ -12317,6 +12490,23 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
       const returnStmt = children2.length === 0 ? body2.statements.find(
         (s) => ts12.isReturnStatement(s) && s.expression != null
       ) : void 0;
+      let rowScopeBeforePreamble = null;
+      if (returnStmt) {
+        const preambleNames = /* @__PURE__ */ new Set();
+        for (const stmt of body2.statements) {
+          if (stmt === returnStmt) break;
+          collectPreambleDeclaredNames(stmt, preambleNames);
+        }
+        if (preambleNames.size > 0) {
+          rowScopeBeforePreamble = ctx2.scope;
+          ctx2.scope = savedScope.enterLoopRow({
+            param,
+            index,
+            paramBindings,
+            preamble: { declaredNames: [...preambleNames] }
+          });
+        }
+      }
       if (returnStmt && returnStmt.expression) {
         let returnExpr = returnStmt.expression;
         while (ts12.isParenthesizedExpression(returnExpr)) {
@@ -12408,6 +12598,9 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
           }
         }
       }
+      if (rowScopeBeforePreamble) {
+        ctx2.scope = rowScopeBeforePreamble;
+      }
       if (method2 === "flatMap" && children2.length === 0 && !flatMapProjectionCall(body2)) {
         flatMapCallback = buildFlatMapCallback(callback, body2, ctx2);
       }
@@ -12441,12 +12634,7 @@ function transformMapCall(node, ctx2, isClientOnly = false, method2 = "map") {
         )
       );
     }
-    if (paramBindings) {
-      for (const b of paramBindings) ctx2.loopParams.delete(b.name);
-    } else {
-      ctx2.loopParams.delete(param);
-    }
-    if (index) ctx2.loopParams.delete(index);
+    ctx2.scope = savedScope;
     ctx2.loopDepth--;
   }
   if (children2.length === 0 && !flatMapCallback) {
@@ -13207,7 +13395,7 @@ function parseTemplateLiteral(expr, ctx2) {
 }
 function tryResolveTemplateSpanFromConst(expr, ctx2) {
   if (ts12.isIdentifier(expr)) {
-    if (ctx2.loopParams.has(expr.text)) return null;
+    if (ctx2.scope.isBound(expr.text)) return null;
     const constInfo = findLocalConst(expr.text, ctx2.analyzer);
     if (!constInfo) return null;
     const ast = parseConstInitializer(constInfo);
@@ -13219,7 +13407,7 @@ function tryResolveTemplateSpanFromConst(expr, ctx2) {
   }
   if (ts12.isElementAccessExpression(expr)) {
     if (!ts12.isIdentifier(expr.expression)) return null;
-    if (ctx2.loopParams.has(expr.expression.text)) return null;
+    if (ctx2.scope.isBound(expr.expression.text)) return null;
     const constInfo = findLocalConst(expr.expression.text, ctx2.analyzer);
     if (!constInfo) return null;
     const ast = parseConstInitializer(constInfo);
@@ -13285,7 +13473,7 @@ function hasDynamicTagBinding(name2, sourceFile) {
   return found;
 }
 function tryResolveIdentifierAsTemplateLiteral(ident, ctx2) {
-  if (ctx2.loopParams.has(ident.text)) return null;
+  if (ctx2.scope.isBound(ident.text)) return null;
   const constInfo = findLocalConst(ident.text, ctx2.analyzer);
   if (!constInfo) return null;
   const ast = parseConstInitializer(constInfo);
@@ -13621,8 +13809,9 @@ function isSignalOrMemoArray(array, ctx2) {
   return false;
 }
 function referencesLoopParam(expr, ctx2) {
-  if (ctx2.loopParams.size === 0) return false;
-  for (const p of ctx2.loopParams) {
+  const boundNames = ctx2.scope.valueBoundNames();
+  if (boundNames.size === 0) return false;
+  for (const p of boundNames) {
     if (new RegExp(`\\b${p}\\b`).test(expr)) return true;
   }
   return false;
@@ -13688,8 +13877,9 @@ function hasReactiveAttributes(attrs, ctx2) {
     if (isSignalOrMemoReference(valueToCheck, ctx2) || isPropsReference(valueToCheck, ctx2)) {
       return true;
     }
-    if (ctx2.loopParams.size > 0) {
-      for (const p of ctx2.loopParams) {
+    const scopeValueNames = ctx2.scope.valueBoundNames();
+    if (scopeValueNames.size > 0) {
+      for (const p of scopeValueNames) {
         if (new RegExp(`\\b${p}\\b`).test(valueToCheck)) return true;
       }
     }
@@ -13913,6 +14103,7 @@ var init_jsx_to_ir = __esm({
     init_strip_types();
     init_template_parts();
     init_src();
+    init_binding_scope();
     CLIENT_DIRECTIVE_INTERIOR_RE2 = /^\s*@client\s*$/;
     BLOCK_COMMENT_RE2 = /\/\*([\s\S]*?)\*\//g;
     EMPTY_BOUND = /* @__PURE__ */ new Set();
@@ -24937,7 +25128,7 @@ var init_jsx_adapter = __esm({
           if (moduleScopeNames.has(constant.name)) continue;
           const keyword = constant.declarationKind ?? "const";
           if (!constant.value) {
-            const typeAnnotation = preserveTypes && constant.type ? `: ${constant.type.raw}` : "";
+            const typeAnnotation = preserveTypes && (constant.typeAnnotation ?? constant.type) ? `: ${constant.typeAnnotation ?? constant.type?.raw}` : "";
             lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`);
             continue;
           }
@@ -24945,7 +25136,8 @@ var init_jsx_adapter = __esm({
           if (/^createContext\b/.test(value2) || /^new WeakMap\b/.test(value2)) continue;
           if (!reachable.has(constant.name)) continue;
           const constValue = preserveTypes ? constant.typedValue ?? constant.value : constant.value;
-          lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
+          const letTypeAnnotation = preserveTypes && keyword === "let" && constant.typeAnnotation ? `: ${constant.typeAnnotation}` : "";
+          lines.push(`  ${keyword} ${constant.name}${letTypeAnnotation} = ${constValue}`);
         }
         for (const func of localFunctions) {
           if (moduleScopeNames.has(func.name)) continue;
@@ -25102,14 +25294,16 @@ var init_jsx_adapter = __esm({
           const keyword = c.declarationKind ?? "const";
           const exportKw = c.isExported ? "export " : "";
           if (!c.value) {
-            entries2.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}` });
+            const typeAnnotation = preserveTypes && (c.typeAnnotation ?? c.type) ? `: ${c.typeAnnotation ?? c.type?.raw}` : "";
+            entries2.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${typeAnnotation}` });
             continue;
           }
           const trimmed = c.value.trim();
           if (/^new WeakMap\b/.test(trimmed)) continue;
           if (c.isExported && /^createContext\b/.test(trimmed)) continue;
           const value2 = preserveTypes ? c.typedValue ?? c.value : c.value;
-          entries2.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name} = ${value2}` });
+          const letTypeAnnotation = preserveTypes && keyword === "let" && c.typeAnnotation ? `: ${c.typeAnnotation}` : "";
+          entries2.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${letTypeAnnotation} = ${value2}` });
         }
         for (const f of ir.metadata.localFunctions) {
           if (!f.isModule || !moduleNames.has(f.name)) continue;
@@ -28832,6 +29026,7 @@ __export(src_exports, {
   BROWSER_ONLY_CLIENT_APIS: () => BROWSER_ONLY_CLIENT_APIS,
   BUILTIN_LOWERING_PLUGINS: () => BUILTIN_LOWERING_PLUGINS,
   BaseAdapter: () => BaseAdapter,
+  BindingScope: () => BindingScope,
   CALLBACK_METHODS: () => CALLBACK_METHODS,
   ENV_SIGNAL_READERS: () => ENV_SIGNAL_READERS,
   ErrorCodes: () => ErrorCodes,
@@ -29031,6 +29226,7 @@ var init_src2 = __esm({
     init_expression_parser();
     init_loop_chain();
     init_loop_destructure();
+    init_binding_scope();
     init_debug();
     init_profiler();
     init_debug_profile();

package/package.json

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