@barefootjs/jsx 0.17.0 → 0.18.0

package/src/analyzer-context.ts

@@ -268,6 +268,26 @@ export function createAnalyzerContext(
     checker: null,
     componentBodyBlock: null,
     getJS(node: ts.Node): string {
+      // A node whose owning source file differs from this component's
+      // `sourceFile` comes from a synthetic re-parse — e.g. #2090's
+      // resolved sort-comparator functions, or #2092's desugared
+      // tagged-template-literal callee — rather than a live position in
+      // this file. `reconstructWithoutTypes` slices `sourceFile.text` by
+      // the node's start/end, so feeding it a foreign node's positions
+      // would silently slice the WRONG bytes (not throw). These synthetic
+      // subtrees are already built from plain re-parsed source text with
+      // no straggling TS type syntax to strip, so the node's own text is
+      // correct as-is — mirrors the `astText()` workaround already used
+      // for synthetic const/function re-parses elsewhere in the compiler.
+      let ownSourceFile: ts.SourceFile | undefined
+      try {
+        ownSourceFile = node.getSourceFile()
+      } catch {
+        ownSourceFile = undefined
+      }
+      if (ownSourceFile && ownSourceFile !== sourceFile) {
+        return node.getText(ownSourceFile)
+      }
       return reconstructWithoutTypes(node, sourceFile, this.typeExcludeRanges)
     },
   }

package/src/analyzer.ts

@@ -3011,6 +3011,12 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
       hasIgnoreDirective: ignored,
     }
 
+    // Resolve each destructured binding's declared type from the param's type
+    // annotation, so `{ value }: Props` keeps the same per-prop TypeInfo as the
+    // `props: Props` path instead of degrading to `unknown` (which typed
+    // adapters emit as `interface{}` + an unchecked assertion). See issue #2150.
+    const memberTypes = param.type ? collectMemberTypes(param.type, ctx) : null
+
     for (const element of param.name.elements) {
       if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
         const localName = element.name.text
@@ -3022,10 +3028,19 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
           continue
         }
 
+        // Aliased bindings (`{ value: v }`) take their type from the source
+        // property name, not the local alias.
+        const sourcePropName =
+          element.propertyName && ts.isIdentifier(element.propertyName)
+            ? element.propertyName.text
+            : localName
+        const resolvedType: TypeInfo =
+          memberTypes?.get(sourcePropName) ?? { kind: 'unknown', raw: 'unknown' }
+
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false
         ctx.propsParams.push({
           name: localName,
-          type: { kind: 'unknown', raw: 'unknown' },
+          type: resolvedType,
           optional: !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined,
@@ -3108,6 +3123,64 @@ function collectKeysFromMembers(
   return keys
 }
 
+/**
+ * Build a property-name -> resolved TypeInfo map from a props type annotation,
+ * for destructured params (`{ value }: Props`) so they carry the same per-prop
+ * types the props-object path (`props: Props`) already resolves. Returns null
+ * for external/unresolvable types.
+ *
+ * Scope (deliberately narrow — targets the panic in issue #2150):
+ * - Only REQUIRED members are resolved. Optional members (`value?: T`) are left
+ *   out so they keep degrading to `unknown` -> `interface{}`: typed adapters
+ *   rely on that nillable field to omit an unset optional attribute
+ *   (`{{if ne .X nil}}` in Go), which a concrete zero value could not express.
+ * - Only PRIMITIVE members (string/number/boolean) are resolved. Those are the
+ *   types that otherwise produce an unchecked scalar assertion (`in.X.(int)`)
+ *   that panics. Arrays/objects/functions are left as `unknown` because typed
+ *   adapters lower them through interface{}-based helpers (`bf_flat`, spread,
+ *   `bf_json`); giving them concrete types would break that lowering and is a
+ *   larger, separate change.
+ */
+function collectMemberTypes(
+  typeNode: ts.TypeNode,
+  ctx: AnalyzerContext
+): Map<string, TypeInfo> | null {
+  const isResolvablePrimitive = (info: TypeInfo): boolean =>
+    info.kind === 'primitive' &&
+    (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')
+
+  const fromMembers = (members: ts.NodeArray<ts.TypeElement>): Map<string, TypeInfo> => {
+    const map = new Map<string, TypeInfo>()
+    for (const member of members) {
+      if (ts.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
+        const info = typeNodeToTypeInfo(member.type, ctx.sourceFile)
+        if (info && isResolvablePrimitive(info)) {
+          map.set(member.name.getText(ctx.sourceFile), info)
+        }
+      }
+    }
+    return map
+  }
+
+  if (ts.isTypeLiteralNode(typeNode)) {
+    return fromMembers(typeNode.members)
+  }
+
+  if (ts.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(ctx.sourceFile)
+    const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile)
+    if (!typeDecl) return null
+    if (ts.isInterfaceDeclaration(typeDecl)) {
+      return fromMembers(typeDecl.members)
+    }
+    if (ts.isTypeAliasDeclaration(typeDecl) && ts.isTypeLiteralNode(typeDecl.type)) {
+      return fromMembers(typeDecl.type.members)
+    }
+  }
+
+  return null
+}
+
 /**
  * Extract props parameters from a type annotation.
  * Supports type literals and type references to local interfaces.

package/src/augment-inherited-props.ts

@@ -32,6 +32,25 @@ export interface ContextConsumer {
    * absent / not a literal (the consumer then defaults to the empty value).
    */
   defaultValue: string | number | boolean | null
+  /**
+   * Set to `'object'` when the `createContext(<default>)` argument is an
+   * OBJECT LITERAL (`createContext<{ config: X }>({ config: {} })`) — a shape
+   * `defaultValue` alone can't distinguish from "no default at all" (both
+   * collapse to `null`). Adapters with a live SSR context stack (twig, jinja,
+   * erb, minijinja, xslate, mojolicious) never read this: their consumer seed
+   * (`bf.use_context(name, default)`) only matters when NO enclosing Provider
+   * ran, and every existing fixture exercising an object-shaped default keeps
+   * its consumer nested inside a Provider that supplies a live value at
+   * render time — see each adapter's `memo/seed.ts` (or equivalent). Go has no
+   * such runtime stack: it bakes the Provider's value into the descendant's
+   * constructor call at COMPILE time (`extendProviderContext` /
+   * `emitStaticChildInstances`, go-template-adapter.ts), so an object-shaped
+   * default needs its own Go type (`map[string]interface{}`, not the scalar
+   * `string` fallback `contextConsumerGoType` used to pick for every
+   * non-literal default) — `defaultKind` is what lets it tell "object" apart
+   * from "no default" (#2087).
+   */
+  defaultKind?: 'object'
 }
 
 /**
@@ -44,9 +63,15 @@ export function collectContextConsumers(metadata: IRMetadata): ContextConsumer[]
   const constants = metadata.localConstants ?? []
   // Map each createContext const name → its default-arg literal value.
   const contextDefaults = new Map<string, string | number | boolean | null>()
+  // Map each createContext const name → 'object' when its default is an
+  // object-literal (a shape `contextDefaults` alone can't distinguish from
+  // "no default" — both parse to `null`). Only Go consults this (see
+  // `ContextConsumer.defaultKind`'s docstring).
+  const contextDefaultKinds = new Map<string, 'object'>()
   for (const c of constants) {
     if (c.systemConstructKind !== 'createContext' || c.value === undefined) continue
     contextDefaults.set(c.name, parseCreateContextDefault(c.value))
+    if (isObjectLiteralCreateContextDefault(c.value)) contextDefaultKinds.set(c.name, 'object')
   }
   if (contextDefaults.size === 0) return []
 
@@ -59,6 +84,7 @@ export function collectContextConsumers(metadata: IRMetadata): ContextConsumer[]
       localName: c.name,
       contextName: ctxName,
       defaultValue: contextDefaults.get(ctxName) ?? null,
+      defaultKind: contextDefaultKinds.get(ctxName),
     })
   }
   return consumers
@@ -87,6 +113,14 @@ function parseCreateContextDefault(source: string): string | number | boolean |
   return null
 }
 
+/** True when `createContext(<arg>)`'s argument is an object-literal (`{ config: {} }`). */
+function isObjectLiteralCreateContextDefault(source: string): boolean {
+  const expr = parseSingleExpression(source)
+  if (!expr || !ts.isCallExpression(expr)) return false
+  if (expr.arguments.length === 0) return false
+  return ts.isObjectLiteralExpression(expr.arguments[0])
+}
+
 function parseSingleExpression(source: string): ts.Expression | null {
   const sf = ts.createSourceFile('__ctx.ts', `(${source})`, ts.ScriptTarget.Latest, false)
   const stmt = sf.statements[0]
@@ -139,14 +173,65 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
   const booleanAttrProps = new Set<string>()
   const accessed = new Set<string>()
   const accessRe = new RegExp(`(?:^|[^\\w$.])${propsObj}\\.([A-Za-z_$][\\w$]*)`, 'g')
-  const scan = (s: string | undefined): void => {
+  const scan = (s: string | undefined, also?: Set<string>): void => {
     if (!s) return
-    for (const m of s.matchAll(accessRe)) accessed.add(m[1])
+    for (const m of s.matchAll(accessRe)) {
+      accessed.add(m[1])
+      also?.add(m[1])
+    }
+  }
+
+  // Coalesce-literal type pins: a read of the form `props.X ?? <literal>`
+  // (or `|| <literal>`) fixes X's type to the literal's. The Go adapter
+  // seeds a prop-derived signal/memo constructor from the synthetic field
+  // (`Count: in.Initial` where `Count int` came from evaluating
+  // `props.initial ?? 0`), so classifying `initial` with the string
+  // default produces a Go type mismatch the compiler rejects.
+  const coalesceLiteralTypes = new Map<string, 'number' | 'boolean' | 'string'>()
+  const pinCoalesceLiterals = (s: string | undefined): void => {
+    if (!s || !s.includes(propsObj)) return
+    const sf = ts.createSourceFile('__aug.ts', `(${s})`, ts.ScriptTarget.Latest, false)
+    const visit = (n: ts.Node): void => {
+      if (
+        ts.isBinaryExpression(n) &&
+        (n.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+          n.operatorToken.kind === ts.SyntaxKind.BarBarToken)
+      ) {
+        let left: ts.Expression = n.left
+        while (ts.isParenthesizedExpression(left)) left = left.expression
+        if (
+          ts.isPropertyAccessExpression(left) &&
+          ts.isIdentifier(left.expression) &&
+          left.expression.text === propsObj
+        ) {
+          const name = left.name.text
+          let right: ts.Expression = n.right
+          while (ts.isParenthesizedExpression(right)) right = right.expression
+          if (ts.isPrefixUnaryExpression(right)) right = right.operand
+          const kind = ts.isNumericLiteral(right)
+            ? 'number'
+            : right.kind === ts.SyntaxKind.TrueKeyword || right.kind === ts.SyntaxKind.FalseKeyword
+              ? 'boolean'
+              : ts.isStringLiteralLike(right)
+                ? 'string'
+                : null
+          if (kind && !coalesceLiteralTypes.has(name)) coalesceLiteralTypes.set(name, kind)
+        }
+      }
+      ts.forEachChild(n, visit)
+    }
+    visit(sf)
   }
 
   // Memos, signals, init statements, effects: any `props.X` read.
-  for (const memo of ir.metadata.memos) scan(memo.computation)
-  for (const signal of ir.metadata.signals) scan(signal.initialValue)
+  for (const memo of ir.metadata.memos) {
+    scan(memo.computation)
+    pinCoalesceLiterals(memo.computation)
+  }
+  for (const signal of ir.metadata.signals) {
+    scan(signal.initialValue)
+    pinCoalesceLiterals(signal.initialValue)
+  }
   for (const stmt of ir.metadata.initStatements ?? []) scan(stmt.body)
   for (const eff of ir.metadata.effects ?? []) scan((eff as { body?: string }).body)
 
@@ -157,12 +242,58 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
   for (const c of ir.metadata.localConstants ?? []) {
     if (c.isModule) continue
     scan(c.value)
+    pinCoalesceLiterals(c.value)
   }
 
   // Template attribute exprs — also note bare-ref / boolean usage.
   const walk = (node: IRNode | undefined): void => {
     if (!node) return
+    // Non-attribute expression carriers (#2126 follow-up): a `props.X`
+    // read can reach the template as a bare scalar through a dynamic
+    // text child (`<p>{props.label}</p>`), a conditional / if-statement
+    // condition (`{props.show && …}`), or a loop's array expression
+    // (`(props.items ?? []).map(…)`). With a typed props object those
+    // names are already in `propsParams`; with an untyped `props`
+    // parameter these reads were invisible to this pass, so the emitted
+    // template referenced a var the props type / ssrDefaults never
+    // declared (a strict-mode 500 on Perl-family adapters, a missing
+    // struct field on Go). Text reads keep the default `string`
+    // classification; condition / loop-array reads land in the nillable
+    // bucket (`unknown` → omittable/interface-typed) since their values
+    // are only ever truth-tested or iterated.
+    const carrier = node as unknown as { type?: string; expr?: string; condition?: string; array?: string }
+    if (carrier.type === 'expression') {
+      scan(carrier.expr)
+      pinCoalesceLiterals(carrier.expr)
+    }
+    scan(carrier.condition, bareRefProps)
+    pinCoalesceLiterals(carrier.condition)
+    scan(carrier.array, bareRefProps)
     const el = node as unknown as IRElement
+    // Component nodes carry the same AttrValue shapes under `props`
+    // (`<Child value={props.foo} />` reads `$foo` at child-props
+    // construction time in the SSR template) — but they are NOT HTML
+    // attributes: boolean-attr inference by name doesn't apply, and the
+    // value's type belongs to the child's contract, not to how this
+    // component renders it. Classify these reads as nillable (`unknown`)
+    // unless a `?? <literal>` pins a concrete type.
+    for (const prop of (node as unknown as { props?: IRElement['attrs'] }).props ?? []) {
+      const v = prop.value as { kind?: string; expr?: string; parts?: Array<{ type: string } & Record<string, string>> }
+      if (v?.parts) {
+        for (const part of v.parts) {
+          if (part.type === 'string') scan(part.value)
+          else if (part.type === 'ternary') {
+            scan(part.condition)
+            scan(part.whenTrue)
+            scan(part.whenFalse)
+          } else if (part.type === 'lookup') scan(part.key)
+        }
+      }
+      if (v?.kind === 'expression' && typeof v.expr === 'string') {
+        scan(v.expr, bareRefProps)
+        pinCoalesceLiterals(v.expr)
+      }
+    }
     for (const attr of el.attrs ?? []) {
       const v = attr.value as {
         kind?: string
@@ -231,14 +362,13 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
     if (existing.has(name)) continue
     let raw: string
     if (booleanAttrProps.has(name)) raw = 'boolean'
+    else if (coalesceLiteralTypes.has(name)) raw = coalesceLiteralTypes.get(name)!
     else if (bareRefProps.has(name)) raw = 'unknown' // → interface{} (nillable, omittable)
     else raw = 'string' // read in a memo / string context (e.g. className)
     const type: TypeInfo =
-      raw === 'boolean'
-        ? { kind: 'primitive', raw: 'boolean', primitive: 'boolean' }
-        : raw === 'string'
-          ? { kind: 'primitive', raw: 'string', primitive: 'string' }
-          : { kind: 'unknown', raw: 'unknown' }
+      raw === 'unknown'
+        ? { kind: 'unknown', raw: 'unknown' }
+        : { kind: 'primitive', raw, primitive: raw as 'string' | 'number' | 'boolean' }
     ir.metadata.propsParams.push({ name, type, optional: true })
     existing.add(name)
   }

package/src/compiler.ts

@@ -23,6 +23,7 @@ import { generateModuleExports, collectInlineExportedNames } from './module-expo
 import { applyCssLayerPrefix } from './css-layer-prefixer.ts'
 import { preprocessInlineJsxCallbacks } from './preprocess-inline-jsx-callbacks.ts'
 import { extractSsrDefaults } from './ssr-defaults.ts'
+import { computeSsrSeedPlan } from './ssr-seed-plan.ts'
 
 /**
  * Extended compile options with required adapter
@@ -275,6 +276,7 @@ function compileMultipleComponents(
         path: dir + output.componentName + adapter.extension,
         content: output.rawTemplate,
         type: 'markedTemplate',
+        componentName: output.componentName,
       })
       // SSR defaults, paired with the per-component template file via
       // the matching basename (the build pipeline pairs them in
@@ -286,6 +288,7 @@ function compileMultipleComponents(
           path: dir + output.componentName + '.ssr-defaults.json',
           content: JSON.stringify(ssrDefaults),
           type: 'ssrDefaults',
+          componentName: output.componentName,
         })
       }
     }
@@ -482,7 +485,7 @@ function compileMultipleComponents(
 export function buildMetadata(
   ctx: ReturnType<typeof analyzeComponent>,
 ): IRMetadata {
-  return {
+  const metadata: IRMetadata = {
     componentName: ctx.componentName || 'Unknown',
     hasDefaultExport: ctx.hasDefaultExport,
     isExported: ctx.isExported,
@@ -512,6 +515,10 @@ export function buildMetadata(
     localFunctions: ctx.localFunctions,
     localConstants: ctx.localConstants,
   }
+  // Computed from the assembled metadata (not `ctx`): the plan reads the
+  // exact fields adapters see, so the two can never disagree.
+  metadata.ssrSeedPlan = computeSsrSeedPlan(metadata)
+  return metadata
 }
 
 // =============================================================================
@@ -667,6 +674,7 @@ export function compileJSX(
     path: filePath.replace(/\.tsx?$/, adapter.extension),
     content,
     type: 'markedTemplate',
+    componentName: componentIR.metadata.componentName,
   })
 
   // SSR defaults — JSON-encoded seed values for the template's
@@ -681,6 +689,7 @@ export function compileJSX(
         path: filePath.replace(/\.tsx?$/, '.ssr-defaults.json'),
         content: JSON.stringify(ssrDefaults),
         type: 'ssrDefaults',
+        componentName: componentIR.metadata.componentName,
       })
     }
   }