@barefootjs/jsx 0.31.3 → 0.31.5

package/src/scope/binding-scope.ts

@@ -201,7 +201,7 @@ export class BindingScope {
    *     qualifies, including a preamble local shadowing a module const.
    *     These call `isBound` / `boundNames()`.
    *   - REACTIVITY / SLOT-ID CLASSIFIERS (`referencesLoopParam`,
-   *     `hasReactiveAttributes`, and the `BindingEnvironment.loopParams`
+   *     `hasReactiveAttributes`, and the `BindingEnvironment.loopValueBoundNames`
    *     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

package/src/types.ts

@@ -901,6 +901,28 @@ export interface MapCallbackPreamble {
    * keeps the plain interpolation it always had.
    */
   builderNames: string[]
+  /**
+   * The subset of {@link declaredNames} whose OWN initializer is itself
+   * reactive — reads a signal / memo / reactive prop, directly or
+   * transitively through an earlier preamble declaration (#2596). `undefined`
+   * (never an empty array) when the preamble contributes no such name, or
+   * when it isn't a value-only declaration sequence this analysis covers
+   * (see `preambleFromValueStatements`'s caller — a JSX-building preamble
+   * doesn't compute this and leaves it unset).
+   *
+   * Used to decide whether a loop-body CONDITIONAL whose condition
+   * bare-references a preamble local should carry the IR `reactive` flag
+   * (`markPreambleConditionalReactivity`, jsx-to-ir.ts). Deliberately NOT the
+   * same test `collectPreambleRegions`/`markPreambleAttrSlots` use for
+   * text/attr positions — those mark ANY reference to `declaredNames`
+   * reactive because their region-patch effect re-runs the whole preamble
+   * unconditionally on row update, and ordinary signal auto-tracking inside
+   * that effect picks up genuine dependencies regardless of the IR flag. A
+   * conditional instead swaps whole DOM subtrees via `insert()`, so it stays
+   * unwrapped unless the local it reads is proven to depend on an actual
+   * external signal — a bare `item.title`-derived local needs no such wrap.
+   */
+  reactiveNames?: string[]
 }
 
 /**
@@ -1940,6 +1962,25 @@ export interface IRMetadata {
   isClientComponent: boolean
   typeDefinitions: TypeDefinition[]
   propsType: TypeInfo | null
+  /**
+   * The component function's own generic type parameter list, verbatim
+   * from source (each `node.getText()`, joined and wrapped in `<...>`),
+   * e.g. `<NodeType extends NodeBase = NodeBase, EdgeType extends
+   * EdgeBase = EdgeBase>`. `null` when the component isn't generic.
+   *
+   * A generic function component's props type (and often its body) keeps
+   * referencing these names verbatim in emitted output (e.g. `props:
+   * FlowComponentProps<NodeType, EdgeType>`, `createFlowStore<NodeType,
+   * EdgeType>(props)`) — without the function's own declaration also
+   * carrying the type parameters, those references are unresolved names
+   * in the emitted `.tsx` (TS2304). Emitters that print a `function
+   * <name>(...)` signature for the component must splice this verbatim
+   * between the name and the parameter list. Optional (rather than
+   * required) so the many hand-built `IRMetadata` test fixtures across
+   * the suite don't need updating for a field that is `null` for the
+   * overwhelming majority of (non-generic) components.
+   */
+  typeParameters?: string | null
   propsParams: ParamInfo[]
   /** Name of the props object parameter (e.g., 'props' in `function Component(props: Props)`) */
   propsObjectName: string | null