@barefootjs/jsx 0.19.0 → 0.20.0

package/src/analyzer.ts

@@ -1226,11 +1226,27 @@ function collectSignal(node: ts.VariableDeclaration, ctx: AnalyzerContext): void
   // the binding actually in scope rather than a hardcoded canonical name (#2057).
   const envFactory = envReader ? callExpr.expression.getText(ctx.sourceFile) : undefined
 
+  // Destructured-arg components only (#2265): a signal's initial value
+  // referencing a bare destructured prop (`createSignal(size ?? 1)` with
+  // `{ size }: { size?: number }`) needs `_p.size` for the CSR
+  // `template:` arrow's module-scope SSR fallback — that arrow isn't a
+  // closure over `initXxx`'s `const size = _p.size` extraction. Mirrors
+  // the local-constant rewrite a few hundred lines up (`propNames` built
+  // the same way from `ctx.propsParams`).
+  let templateInitialValue: string | undefined
+  if (!ctx.propsObjectName && callExpr.arguments[0]) {
+    const propNames = new Set(ctx.propsParams.map(p => p.name))
+    if (propNames.size > 0) {
+      templateInitialValue = rewriteBarePropRefs(initialValue, callExpr.arguments[0], propNames)
+    }
+  }
+
   ctx.signals.push({
     getter,
     setter,
     initialValue,
     typedInitialValue: typedInitialValue !== initialValue ? typedInitialValue : undefined,
+    templateInitialValue,
     type,
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
     initialFreeIdentifiers: callExpr.arguments[0]
@@ -3052,6 +3068,8 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
           optional: !!member?.optional || !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined,
+          // Only aliased bindings carry the source key — see ParamInfo.sourceName.
+          ...(sourcePropName !== localName && { sourceName: sourcePropName }),
         })
       }
     }

package/src/compiler.ts

@@ -24,6 +24,7 @@ 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'
+import { checkRichTypeMethodCalls } from './rich-type-refusal.ts'
 
 /**
  * Extended compile options with required adapter
@@ -137,6 +138,7 @@ function compileMultipleComponents(
     }
 
     componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR)
+    checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors)
 
     if (options.cssLayerPrefix) {
       applyCssLayerPrefix(componentIR, options.cssLayerPrefix)
@@ -615,6 +617,7 @@ export function compileJSX(
 
   // Pre-compute client JS analysis for adapter optimization
   componentIR.metadata.clientAnalysis = analyzeClientNeeds(componentIR)
+  checkRichTypeMethodCalls(componentIR.root, componentIR.metadata, errors)
 
   // Cross-file @client signal sources: identify which import sources
   // need `.client.js` path rewriting in the client bundle.

package/src/expression-parser.ts

@@ -591,6 +591,58 @@ export function cssKebabCase(name: string): string {
   return name.replace(/[A-Z]/g, m => '-' + m.toLowerCase()).replace(/^ms-/, '-ms-')
 }
 
+/**
+ * Whether a dynamic CSS style VALUE is "unsafe" — the CSS-injection guard
+ * Hono's real JSX runtime (`hono/jsx/utils.ts`'s `hasUnsafeStyleValue`,
+ * the ORACLE this compiler's adapters must match, #2261) applies before
+ * emitting a `style={{...}}` object-literal property. A value flagged
+ * unsafe is DROPPED — the whole `key:value` pair is omitted from the CSS
+ * string — rather than escaped; this is a hand-rolled structural scan for
+ * characters that could break out of a CSS declaration (unbalanced
+ * quotes/brackets, `{`/`}`, a bare `;`, an unterminated CSS comment
+ * or backslash-escape), NOT real CSSOM property validation. Ported
+ * character-for-character (character-CODE comparisons, not codepoints —
+ * every tested character is ASCII, so scanning consistently by UTF-16
+ * code unit, byte, or codepoint all agree) so every adapter's own port
+ * (Go/Ruby/Python/Rust/PHP/Perl) stays byte-isomorphic with this
+ * reference and with Hono.
+ */
+export function hasUnsafeStyleValue(value: string): boolean {
+  let quote = 0
+  const blockStack: number[] = []
+  for (let i = 0, len = value.length; i < len; i++) {
+    const c = value.charCodeAt(i)
+    if (c === 92) {
+      // backslash — an escape sequence; an escape at the very end (nothing
+      // to escape) is unsafe, else skip the escaped character.
+      if (i === len - 1) return true
+      i++
+    } else if (quote !== 0) {
+      if (c === 10 || c === 12 || c === 13) return true // \n \f \r inside a quoted string
+      if (c === quote) quote = 0
+    } else if (c === 47 && value.charCodeAt(i + 1) === 42) {
+      // "/*" comment start — must close before the value ends.
+      const end = value.indexOf('*/', i + 2)
+      if (end === -1) return true
+      i = end + 1
+    } else if (c === 34 || c === 39) {
+      quote = c // " or '
+    } else if (c === 40) {
+      blockStack.push(41) // ( expects a matching )
+    } else if (c === 91) {
+      blockStack.push(93) // [ expects a matching ]
+    } else if (c === 123 || c === 125) {
+      return true // { or } — always unsafe
+    } else if (c === 41 || c === 93) {
+      if (blockStack[blockStack.length - 1] !== c) return true // mismatched close
+      blockStack.pop()
+    } else if (c === 59 && blockStack.length === 0) {
+      return true // ; outside any bracket
+    }
+  }
+  return quote !== 0 || blockStack.length !== 0 // unterminated quote/bracket
+}
+
 /**
  * Parse a JSX `style={{ … }}` object-literal source into CSS entries, or
  * `null` when the shape isn't a plain object of static-keyed properties
@@ -3538,7 +3590,13 @@ export function freeIdentifiers(expr: ParsedExpr): Set<string> | null {
       case 'regex':
         return true
       case 'identifier':
-        if (!bound.has(e.name)) free.add(e.name)
+        // `undefined` parses as an `identifier` node (unlike `null`, which
+        // is a `literal`) but is never a scope reference — every adapter
+        // emitter already lowers it to `nil`/`none`/etc. Reporting it as
+        // free wrongly opaques an otherwise-derivable expression (#2260:
+        // `props.pressed !== undefined` in `computeSsrSeedPlan`'s
+        // `classify()`, whose `baseScope` has no `undefined` entry).
+        if (e.name !== 'undefined' && !bound.has(e.name)) free.add(e.name)
         return true
       case 'call': {
         const isBuiltinCallee = evalBuiltinCalleeName(e.callee) !== null

package/src/index.ts

@@ -320,7 +320,7 @@ export {
 export { ErrorCodes, createError, formatError, generateCodeFrame } from './errors.ts'
 
 // Expression Parser
-export { parseExpression, tsNodeToParsedExpr, asCallbackMethodCall, CALLBACK_METHODS, sortComparatorFromArrow, serializeParsedExpr, freeVarsInBody, freeIdentifiers, materializeGetterCalls, isSupported, exprToString, stringifyParsedExpr, identifierPath, parseBlockBody, parseBlockBodyTolerant, foldBlockToExpr, predicateTernaryToLogical, containsHigherOrder, extractArrowBodyExpression, parseStyleObjectEntries, parseProviderObjectLiteral, type ProviderObjectMember, type FoldBlockOptions } from './expression-parser.ts'
+export { parseExpression, tsNodeToParsedExpr, asCallbackMethodCall, CALLBACK_METHODS, sortComparatorFromArrow, serializeParsedExpr, freeVarsInBody, freeIdentifiers, materializeGetterCalls, isSupported, exprToString, stringifyParsedExpr, identifierPath, parseBlockBody, parseBlockBodyTolerant, foldBlockToExpr, predicateTernaryToLogical, containsHigherOrder, extractArrowBodyExpression, parseStyleObjectEntries, hasUnsafeStyleValue, parseProviderObjectLiteral, type ProviderObjectMember, type FoldBlockOptions } from './expression-parser.ts'
 export type { StyleObjectEntry } from './expression-parser.ts'
 export { PARSED_EXPR_KINDS } from './expression-parser.ts'
 export type { ParsedExpr, ObjectLiteralProperty, ParsedStatement, SortComparator, SortKey, FlatDepth, SupportLevel, SupportResult, TemplatePart } from './expression-parser.ts'

package/src/ir-to-client-js/collect-elements.ts

@@ -313,26 +313,24 @@ export function collectInnerLoops(
         const refsOuter = outerLoopParam
           ? new RegExp(`\\b${outerLoopParam}\\b`).test(n.array)
           : false
-        // Per-item bindings for inner loop body. Mirror the gating the
-        // pre-#1244 separate-field shape used:
-        //   - reactiveTexts: only when array references outer loop param
-        //     (otherwise non-outer-param reads stay statically templated).
-        //   - reactiveAttrs / refs: always when ctx is available; the
-        //     attribute SSR template renders the initial value and a
-        //     missing per-item createEffect would freeze it; refs need to
-        //     fire on every renderItem invocation (#1244).
+        // Per-item bindings for inner loop body, collected uniformly when
+        // ctx is available: reactiveTexts / reactiveAttrs / refs are each
+        // classified against the loop's OWN param via `classifyReactivity`,
+        // which already filters out non-reactive reads — a `refsOuter` gate
+        // on texts alone (removed, #2264) wrongly used the FIXED top-level
+        // loop param at every nesting depth, so an innermost loop whose
+        // array only referenced its immediate parent (not the outermost
+        // param) silently dropped its text-child update effect while the
+        // sibling attribute effect (ungated) still fired. Refs need to fire
+        // on every renderItem invocation (#1244).
         //   - events / conditionals: only in `collectBindings` (branch)
         //     mode; the legacy non-branch path didn't wire them on
         //     `NestedLoop` because event delegation handles them through
         //     the parent's bindings instead.
         const bindings: LoopChildBindings = emptyLoopChildBindings()
-        if (refsOuter && ctx) {
-          for (const child of n.children) {
-            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings))
-          }
-        }
         if (ctx) {
           for (const child of n.children) {
+            bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, n.param, n.paramBindings))
             bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, n.param, n.paramBindings))
             bindings.refs.push(...collectLoopChildRefs(child))
           }

package/src/ir-to-client-js/csr-substitute.ts

@@ -474,6 +474,13 @@ function normalizeSignalInitial(signal: SignalInfo, propsObjectName: string | nu
   if (initialValue.startsWith(propsPrefix) && !initialValue.includes('??')) {
     return `${initialValue} ?? ${inferDefaultValue(signal.type)}`
   }
-  return initialValue
+  // Destructured mode (#2265): `templateInitialValue` (when present) has
+  // bare destructured prop refs already rewritten to `_p.X` — the
+  // module-scope CSR `template:` arrow can't see the bare name (it isn't
+  // a closure over `initXxx`'s `const size = _p.size` extraction), which
+  // otherwise throws `ReferenceError` at template-eval time. The `??`
+  // fallback branch above only applies to object-props mode (a raw
+  // `props.X` prefix match), so it's checked against the ORIGINAL value.
+  return signal.templateInitialValue ?? initialValue
 }
 

package/src/ir-to-client-js/generate-init.ts

@@ -99,16 +99,23 @@ export function generateInitFunction(
   let generatedCode = rewritePropsObjectRef(lines.join('\n'), ctx.propsObjectName)
   generatedCode += '\n' + hydrateLine
 
-  const allImportLines = resolveFinalImports(generatedCode, ir, localImportPrefixes)
+  // Substitute module-level declarations BEFORE import detection: a
+  // module-level helper's body (e.g. `buildSheetVMs` calling
+  // `computeSheetGeometry`) only exists in `moduleConstantsCode`, so
+  // scanning `generatedCode` first would miss any import referenced
+  // only from that body and silently drop it (#2283).
   const moduleConstantsCode = emitModuleLevelDeclarations(
     classification.moduleLevelConstants,
     classification.moduleLevelFunctions,
     classification.moduleLevelSignals,
     classification.moduleLevelMemos,
   )
+  // Replacer-function form: a plain replacement string would let literal
+  // `$&`/`$1`/`$$` sequences in user helper bodies or import paths be
+  // reinterpreted by `String.replace`'s special-pattern handling.
+  const codeWithModuleConstants = generatedCode.replace(MODULE_CONSTANTS_PLACEHOLDER, () => moduleConstantsCode)
+  const allImportLines = resolveFinalImports(codeWithModuleConstants, ir, localImportPrefixes)
 
-  return generatedCode
-    .replace(IMPORT_PLACEHOLDER, allImportLines)
-    .replace(MODULE_CONSTANTS_PLACEHOLDER, moduleConstantsCode)
+  return codeWithModuleConstants.replace(IMPORT_PLACEHOLDER, () => allImportLines)
 }
 

package/src/ir-to-client-js/reactivity.ts

@@ -529,8 +529,19 @@ export function collectLoopChildReactiveTexts(
       const originFreeIds = freeIdsFromRefs(n.origin?.freeRefs)
       const expanded = expandConstantForReactivity(n.expr, ctx, originFreeIds)
       // Include if expression reads signals OR references the loop parameter
-      // (loop param becomes a signal accessor via per-item signals).
-      if (classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind === 'none') return
+      // (loop param becomes a signal accessor via per-item signals). Falls
+      // back to the Solid-style AST-flag wrap decision — mirroring
+      // `collectLoopChildReactiveAttrs`'s `callsReactiveGetters` /
+      // `hasFunctionCalls` fallback (#1673) and the top-level text path's
+      // `decideWrapFromAstFlags` gate (`collectElements`'s `expression`
+      // handler) — so a loop-item text read through an opaque helper
+      // (`textAt(i)` where `const textAt = (i) => rows()[i]`, which
+      // `classifyReactivity` can't see through) still gets an update
+      // effect instead of silently freezing at its SSR value (#2282).
+      const reactive =
+        classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== 'none'
+        || decideWrapFromAstFlags(n).wrap
+      if (!reactive) return
       texts.push({
         slotId: n.slotId,
         expression: expanded.expr,

package/src/rich-type-evidence.ts

@@ -0,0 +1,159 @@
+/**
+ * Type-evidence resolution for the rich-type method-call refusal (#2273).
+ *
+ * `resolveReceiverType` answers one question: "what TypeScript type, if any,
+ * does this `ParsedExpr` evaluate to?" — using only the structured metadata
+ * already collected at IR-build time (`propsType` / `typeDefinitions`), never
+ * a fresh type-checker pass. It is deliberately conservative: any receiver
+ * shape it doesn't recognize (a call result, computed access, a local not in
+ * `bindings`, …) resolves to `null` ("no evidence"), which the caller must
+ * treat as "don't flag" rather than "flag as unknown". A false negative here
+ * only misses a refusal; a false positive would incorrectly block valid code.
+ */
+
+import type { IRMetadata, PropertyInfo, TypeInfo } from './types.ts'
+import type { ParsedExpr } from './expression-parser.ts'
+
+/**
+ * Built-in JS/TS types whose instance methods have no catalogued lowering
+ * (spec/subset-conformance.md). A prop typed as one of these is opaque past
+ * this point — the adapters have no structural representation for `Date`,
+ * `Map`, etc., only for the primitives/arrays/plain-objects the IR already
+ * lowers. Names only (no generic args) — compare against `baseTypeName`.
+ *
+ * Two shapes deliberately escape this catalogue (conservative misses, not
+ * bugs — a miss only skips a refusal, never misdiagnoses):
+ *   - keyword-typed `bigint` / `symbol` annotations lower to
+ *     `{ kind: 'unknown' }` in `typeNodeToTypeInfo` (only the object-form
+ *     `BigInt` / `Symbol` type references reach `kind: 'interface'` and
+ *     match here);
+ *   - a local alias of a host type (`type Timestamp = Date`) resolves to
+ *     the alias NAME — `derefNamedType` only fills in `properties` from a
+ *     declaration, it never rewrites `raw` to the alias target — so the
+ *     catalogue lookup sees `Timestamp`, not `Date`.
+ */
+export const HOST_RICH_TYPE_NAMES: ReadonlySet<string> = new Set([
+  'Date',
+  'Map',
+  'Set',
+  'WeakMap',
+  'WeakSet',
+  'URL',
+  'URLSearchParams',
+  'RegExp',
+  'Promise',
+  'Error',
+  'Symbol',
+  'BigInt',
+  'Function',
+])
+
+/**
+ * Strip generic type arguments from a `TypeInfo.raw` string (`Map<string,
+ * string>` → `Map`) so a parametrized host type still matches the bare-name
+ * catalogue above. `raw` is source-verbatim (`typeNodeToTypeInfo`), so this
+ * is a plain substring split on the first `<` — not a type-syntax parse.
+ */
+export function baseTypeName(raw: string): string {
+  const idx = raw.indexOf('<')
+  return (idx === -1 ? raw : raw.slice(0, idx)).trim()
+}
+
+type EvidenceMetadata = Pick<IRMetadata, 'propsType' | 'propsObjectName' | 'propsParams' | 'typeDefinitions'>
+
+/**
+ * Collapse a union to its single non-nullish arm (`Date | null` → `Date`),
+ * recursively, so an optional rich-typed prop still carries evidence. A
+ * union with more than one non-nullish arm has no single answer and is left
+ * as-is (its `kind` is `'union'`, which never matches the `'interface'`
+ * check callers gate on).
+ */
+function isNullishArm(t: TypeInfo): boolean {
+  if (t.kind === 'primitive' && (t.primitive === 'null' || t.primitive === 'undefined')) return true
+  // `null` as a type annotation is a `ts.LiteralTypeNode` (not the
+  // `NullKeyword` `typeNodeToTypeInfo`'s primitive switch checks for), so it
+  // falls through to `{ kind: 'unknown', raw: 'null' }` there — a pre-existing
+  // gap in that shared helper, out of scope to fix here. Match on `raw` too
+  // so `Date | null` still strips down to `Date`.
+  return t.kind === 'unknown' && (t.raw === 'null' || t.raw === 'undefined')
+}
+
+function stripUnion(type: TypeInfo | null): TypeInfo | null {
+  if (!type || type.kind !== 'union' || !type.unionTypes) return type
+  const nonNullish = type.unionTypes.filter((t) => !isNullishArm(t))
+  return nonNullish.length === 1 ? stripUnion(nonNullish[0]) : type
+}
+
+/**
+ * Resolve a named type (`{ kind: 'interface', raw: 'Props' }`) that carries
+ * no inline `properties` to its declaration's field list via
+ * `metadata.typeDefinitions`. A type already carrying properties (an inline
+ * object literal type, or a type resolved from `tsTypeToTypeInfo`) is
+ * returned unchanged — this only fills in the gap left by a *named*
+ * reference, which `typeNodeToTypeInfo` intentionally resolves to
+ * `{ kind: 'interface', raw }` with no member walk of its own.
+ */
+function derefNamedType(type: TypeInfo, meta: EvidenceMetadata): TypeInfo {
+  if (type.kind !== 'interface') return type
+  if (type.properties && type.properties.length > 0) return type
+  const name = baseTypeName(type.raw)
+  const def = meta.typeDefinitions.find((d) => d.name === name)
+  if (!def?.properties) return type
+  return { ...type, properties: def.properties }
+}
+
+/**
+ * Resolve one property's type off an object-shaped receiver type, deref'ing
+ * a named type first (`Props.createdAt`) and stripping a nullable union off
+ * the result (`Date | null` field). Returns `null` when the receiver has no
+ * evidence, or the property isn't found on it.
+ */
+function lookupProperty(objType: TypeInfo | null, propName: string, meta: EvidenceMetadata): TypeInfo | null {
+  const stripped = stripUnion(objType)
+  if (!stripped) return null
+  const deref = derefNamedType(stripped, meta)
+  const prop = deref.properties?.find((p: PropertyInfo) => p.name === propName)
+  return prop ? stripUnion(prop.type) : null
+}
+
+/**
+ * Resolve the TypeInfo of a receiver expression, using only propsType /
+ * propsParams / typeDefinitions and the caller-supplied local bindings.
+ * `bindings` maps a name to its known type — or explicitly to `null` for a
+ * shadow the caller has proven carries no evidence (e.g. an arrow param, a
+ * loop item whose array type isn't known). A `bindings` hit always wins over
+ * the props fallback, matching JS lexical shadowing.
+ *
+ * Only two `ParsedExpr` shapes carry evidence: a bare identifier and a
+ * non-computed member access. Everything else (calls, computed/index
+ * access, literals, …) resolves to `null` — see the module doc.
+ */
+export function resolveReceiverType(
+  expr: ParsedExpr,
+  meta: EvidenceMetadata,
+  bindings: ReadonlyMap<string, TypeInfo | null>,
+): TypeInfo | null {
+  if (expr.kind === 'identifier') {
+    if (bindings.has(expr.name)) return stripUnion(bindings.get(expr.name) ?? null)
+    if (meta.propsObjectName !== null) {
+      // Object-props mode: props are only reachable through the props object,
+      // so a bare identifier is never a prop — treating every name that
+      // happens to match a propsType field as one would misattribute module
+      // consts / imports that share a field's name.
+      return expr.name === meta.propsObjectName ? stripUnion(meta.propsType) : null
+    }
+    // Destructured mode: only a declared param binding is a prop (membership
+    // via propsParams, which carries LOCAL names — including rename targets).
+    // The TYPE must come from propsType.properties keyed by the SOURCE prop
+    // name: propsParams' own `type` degrades to `unknown` for non-primitive
+    // props (`collectMemberTypes`' primitives-only gate).
+    const param = meta.propsParams.find((p) => p.name === expr.name && !p.isRest)
+    if (!param) return null
+    return lookupProperty(meta.propsType, param.sourceName ?? param.name, meta)
+  }
+  if (expr.kind === 'member' && !expr.computed) {
+    const objType = resolveReceiverType(expr.object, meta, bindings)
+    return lookupProperty(objType, expr.property, meta)
+  }
+  return null
+}