@barefootjs/jsx 0.28.1 → 0.30.0

package/src/types.ts

@@ -60,6 +60,13 @@ export interface TypeInfo {
   // For primitives
   primitive?: 'string' | 'number' | 'boolean' | 'null' | 'undefined'
 
+  /** Set when the type is a LITERAL of its primitive family (`'a'`, `42`,
+   *  `true`) — the literal's source value. `typeNodeToTypeInfo` lowers a
+   *  literal type to `kind: 'primitive'` + this field, so family-only
+   *  consumers need no special case and value consumers never re-parse
+   *  `raw`. */
+  literalValue?: string
+
   // For objects/interfaces
   properties?: PropertyInfo[]
 
@@ -854,6 +861,28 @@ export interface MapCallbackPreamble {
   ssrText: TsxSourceText
   /** const/let/function names the preamble declares (D5 key-derivability guard). */
   declaredNames: string[]
+  /**
+   * The whole preamble as backend-neutral value declarations — set only when
+   * EVERY statement is one (#2447). This is the DSL SSR carrier: a template
+   * language cannot execute `segments` (that is JS text, for the client bundle
+   * and for JS-runtime SSR), but it CAN declare a per-row local, and each
+   * declaration's initializer is a {@link ParsedExpr} every adapter already
+   * knows how to emit in its own syntax — the same door `arrayParsed` /
+   * `filterPredicate.predicate` / `sortComparator` go through.
+   *
+   * All-or-nothing on purpose. A preamble is a statement SEQUENCE with
+   * order-dependent scope; lowering the declarable prefix and dropping the rest
+   * would leave later statements' effects missing with no diagnostic — the
+   * silent divergence #2447 was. So one non-declaration statement (an
+   * assignment, a loop, a call for side effects) or one initializer the
+   * expression subset cannot model leaves this `undefined`, and the Phase-1
+   * DSL gate refuses the whole loop with `/* @client *\/` guidance.
+   *
+   * Declarations appear in source order and may read earlier ones; adapters
+   * emit them in order, so an earlier local is in scope for a later
+   * initializer, exactly as in the source.
+   */
+  declarations?: PreambleValueDeclaration[]
   /**
    * The subset of {@link declaredNames} that accumulate JSX leaves — the
    * `push`/`unshift` targets of a `jsx` segment and the declaration targets of
@@ -864,6 +893,25 @@ export interface MapCallbackPreamble {
   builderNames: string[]
 }
 
+/**
+ * One `const`/`let` value declaration from a `.map()` callback preamble, in
+ * backend-neutral form (#2447 — see {@link MapCallbackPreamble.declarations}).
+ * `name` is always a simple identifier: a destructuring binding declares
+ * several names from one initializer, which no adapter has a single per-row
+ * local form for, so that shape refuses instead of being carried here.
+ */
+export interface PreambleValueDeclaration {
+  /** Declared local name (simple identifier binding). */
+  name: string
+  /** Initializer, structured for per-adapter emission. */
+  valueParsed: ParsedExpr
+  /**
+   * Initializer source text, for a diagnostic that needs to quote it. Never an
+   * emission input — emission goes through `valueParsed`.
+   */
+  raw: string
+}
+
 /**
  * One loop-body expression child classified as a preamble-patched region
  * (#2389 — see `IRLoop.preambleRegions`). `expr` is the raw (unwrapped)
@@ -1002,6 +1050,20 @@ export interface IRComponent {
    * Omitted (undefined) for ordinary components to keep IR diffs minimal.
    */
   dynamicTag?: boolean
+  /**
+   * True when this component is a DIRECT member of an `IRLoop.children`
+   * array (the loop's row-root component, e.g. `{rows().map(r => <Row/>)}`).
+   * Such a component owns its own per-row identity and gets a freshly
+   * randomized `bf-s` — it does NOT derive its scope id from the parent
+   * scope + mount slot the way an ordinarily-slotted child does.
+   *
+   * A component nested *below* the row root (e.g. `<li><Badge/></li>` where
+   * `<li>` is the loop row root) is NOT marked — it derives its scope id
+   * from parent scope + slot like any other slotted child. See
+   * `derivesScopeFromSlot` in `./adapters/child-scope.ts`, which is the one
+   * predicate every backend must consult instead of re-deriving this fact.
+   */
+  loopItemRoot?: boolean
   loc: SourceLocation
 }
 
@@ -1399,6 +1461,15 @@ export interface SignalInfo {
    * AST-level pre-rewrite).
    */
   templateInitialValue?: string
+  /**
+   * True for the getter-elided declaration form `const [, setX] =
+   * createSignal(...)`. `getter` then holds a synthesized internal name
+   * (`__bfGet_<setter>`) that no expression ever references — it exists so
+   * getter-keyed consumers (substitution env, SSR seeding) stay total.
+   * Emit reproduces the source's `[, setter]` hole instead of introducing
+   * the synthesized name into output.
+   */
+  getterElided?: boolean
   type: TypeInfo
   loc: SourceLocation
   /**
@@ -1458,6 +1529,15 @@ export interface SignalInfo {
 export interface MemoInfo {
   name: string
   computation: string
+  /**
+   * `computation` with bare destructured-prop refs rewritten to `_p.X` —
+   * the memo twin of `SignalInfo.templateInitialValue` (#2265). Consumed by
+   * `buildSignalMemoEnv` when the memo body is inlined into the module-scope
+   * CSR `template:` arrow, which is not a closure over init's destructured
+   * extractions (#2468). Only set for destructured-arg components that
+   * actually reference a prop.
+   */
+  templateComputation?: string
   /** Computation with TypeScript type annotations preserved, for .tsx output */
   typedComputation?: string
   /**

package/src/value-references.ts

@@ -26,13 +26,26 @@ import ts from 'typescript'
  * A ShorthandPropertyAssignment (`{ Theme }`) intentionally counts as a
  * reference — it reads the binding, it doesn't just spell its name.
  *
+ * CONTRACT: this classifies identifier positions in **JavaScript** source.
+ * Both current callers parse with `ts.ScriptKind.JS` —
+ * `collectValueReferencedNames` below, and `detectStrippedReferences` in
+ * `packages/cli/src/lib/resolve-imports.ts`, which parses the assembled
+ * bundle. TypeScript-only positions are deliberately NOT handled: an
+ * identifier in a type position (`const x: Foo = …`, a
+ * `TypeReferenceNode`) is still reported as a value reference, and so are
+ * `interface` / `type` / `enum` declaration names. Do not point this at
+ * TypeScript source — it would over-report there.
+ *
  * Caveat: this is a syntactic test, not a scope analysis. If a local
  * function parameter happens to share a name with an imported binding,
  * references inside that function's body will count as references to
- * the import (false positive). Acceptable: over-counting a reference
- * just means we keep an import we didn't strictly need, which is a
- * strict improvement over the alternative failure direction (dropping a
- * needed import and producing a `ReferenceError`).
+ * the import (false positive). For the import-emission caller
+ * (`makeValueUsageTest` in `ir-to-client-js/imports.ts`), over-counting is
+ * the safe direction — an extra import whose binding exists is harmless.
+ * It is NOT safe for the BF053 caller (`detectStrippedReferences`): there,
+ * an over-reported reference to a stripped binding is a false build
+ * error on legal code. That asymmetry is why every exclusion branch below
+ * matters — each one is a case that would otherwise misfire BF053.
  */
 export function isValueReferenceIdentifier(id: ts.Identifier): boolean {
   const parent = id.parent
@@ -47,6 +60,15 @@ export function isValueReferenceIdentifier(id: ts.Identifier): boolean {
   ) {
     return false
   }
+  // Class field name (`class C { helper = 1 }`, including `static helper
+  // = 1`): the name is a member key, not a read. The `parent.name === id`
+  // guard is what preserves the computed case — in `class C { [helper] =
+  // 1 }` the name is a ComputedPropertyName, not `id` itself, so `helper`
+  // (inside the brackets) still falls through and counts as a reference.
+  if (ts.isPropertyDeclaration(parent) && parent.name === id) return false
+  // `new.target` / `import.meta`: `target`/`meta` sits in keyword
+  // position, not a binding.
+  if (ts.isMetaProperty(parent) && parent.name === id) return false
   if (ts.isVariableDeclaration(parent) && parent.name === id) return false
   if (ts.isFunctionDeclaration(parent) && parent.name === id) return false
   if (ts.isFunctionExpression(parent) && parent.name === id) return false