@barefootjs/jsx 0.29.0 → 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
   /**