@barefootjs/jsx 0.33.6 → 0.35.0

package/src/ssr-defaults.ts

@@ -31,6 +31,8 @@
 
 import ts from 'typescript'
 import { extractFreeIdentifiersFromNode } from './analyzer.ts'
+import { resolveGetterAliases, collectAliasableGetterNames } from './ir-to-client-js/csr-substitute.ts'
+import { resolveBodyDestructuredPropAliases } from './props-binding.ts'
 import type { IRMetadata } from './types.ts'
 
 /**
@@ -311,6 +313,49 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     bindings[memo.name] = value
   }
 
+  // #2813: a bare local-const alias of a signal/memo getter
+  // (`const items__alias = items`) is a DIFFERENT identifier from the
+  // getter it aliases, but a template-stash adapter's `.map()` loop over
+  // `items__alias()` looks up the stash entry BY THAT NAME — which the
+  // loops above never create, since they only seed the getter's own
+  // name. Reuses `resolveGetterAliases` (the same alias-hop walker
+  // #2778's CSR-template fix introduced) rather than a third alias-hop
+  // walker: every alias of a getter seeded above gets the SAME entry
+  // under its own name, so the stash has both `items` and `items__alias`
+  // pointing at one value. Env-signal getters are excluded from the
+  // getter-name set (they're never given an `out` entry above — an
+  // adapter's own env-signal binding seeds them instead).
+  {
+    const getterNames = collectAliasableGetterNames(metadata.signals, metadata.memos)
+    for (const [alias, origin] of resolveGetterAliases(metadata.localConstants ?? [], (n) => getterNames.has(n))) {
+      if (alias in out) continue
+      out[alias] = out[origin]
+    }
+  }
+
+  // #2788: a bare-props-form component (`function Foo(props: Props)`)
+  // whose BODY destructures a prop under a different local name
+  // (`const { children: kids } = props`) has no `ParamInfo.sourceName` to
+  // key off above — `propsParams` here comes from the TYPE annotation
+  // (`extractPropsFromTypeMembers`), which has no notion of a body-level
+  // rename. `resolveBodyDestructuredPropAliases` recognizes such a
+  // destructuring statement's `localConstants` shape; seeding the LOCAL
+  // name too (alongside the caller-facing key already seeded above) is
+  // enough to fix what a template-stash adapter's compiled output
+  // actually reads (`v[:kids]` / `$kids`). Without this, a stash-based
+  // adapter reading the renamed local sees an undefined/nil value instead
+  // of the prop — fatal under Perl strict mode (Mojolicious), a
+  // nonexistent Go struct field, or (on an adapter whose runtime
+  // tolerates a missing key) a silent wrong render the moment a caller
+  // actually supplies a value. Parameter-destructuring aliases (`{ n:
+  // count }`) need no such entry — `sourceName`/`name` already handle
+  // that shape via `callerPropName` above.
+  for (const [local, callerKey] of resolveBodyDestructuredPropAliases(metadata.localConstants ?? [], metadata.propsObjectName)) {
+    if (local in out) continue
+    const origin = out[callerKey]
+    if (origin) out[local] = origin
+  }
+
   // Bare-props-arg safety net: the prop block above covers every prop
   // *declared* on the props type, but `propsParams` can miss props read
   // through an untyped / inline-typed `props` object. A signal / memo

package/src/types.ts

@@ -404,18 +404,13 @@ export interface IRText {
 export interface IRExpression {
   type: 'expression'
   expr: string
-  /** Pre-transformed expr with destructured prop refs rewritten to _p.xxx (for client JS templates). */
-  templateExpr?: string
   /**
-   * Marks a VALUE moved into element content by a lowering (today only
-   * `lowerFormControlValueSsr`'s `<textarea>`, #2765) — client builders
-   * must escape it, unlike the normal pre-rendered-HTML `${...}` case.
-   *
-   * Not read via `templateExpr` instead: that field also rebinds to
-   * `_p.xxx`, which drops a destructured prop's `?? {}` default when the
-   * builder's output lives in init scope (`client-js-generation.test.ts`).
+   * Pre-transformed expr with destructured prop refs rewritten to _p.xxx
+   * (for client JS templates). Carries ONLY that rewrite — never an
+   * escaping wrapper: client-side escaping is decided at the splice
+   * (`ir-to-client-js/safe-html.ts`), not baked into IR text (#2795).
    */
-  escapeInClientTemplate?: boolean
+  templateExpr?: string
   /**
    * Structured parse of `expr` (`parseExpression(expr.trim())`), attached once
    * during IR construction so SSR adapters emit from the tree instead of each

package/src/__tests__/text-slot-escaping.test.ts

@@ -1,65 +0,0 @@
-/**
- * Text-slot HTML-escaping emit shape (#1694 + follow-up, #2651).
- *
- * Pins which interpolations the client template wraps in an escape call:
- *   - a plain, non-conditional dynamic text slot (`{stringValue}`) IS
- *     escaped — it becomes the slot's text content under `innerHTML`. Since
- *     #2651 this goes through `escapeTextOrMarkup`, not bare `escapeText`:
- *     the slot is claim-plan `kind: 'markup'` (the value may be a live
- *     `Node`, or a `bfMarkup()`-branded JSX-element-prop value), and
- *     `escapeTextOrMarkup` is a strict superset of `escapeText` for every
- *     non-branded value — this pin's actual escaping behaviour for a plain
- *     string is unchanged, only the call name changed to match the
- *     REACTIVE side's existing `escapeTextOrNode` classification;
- *   - a branch-slot expression (Child-position value inside a conditional
- *     `template()` arrow) is routed through `__bfSlot` and must NOT be
- *     wrapped in either escape call. `__bfSlot` returns raw
- *     `<!--bf-slot:N-->` markers for live nodes; escaping the whole call
- *     corrupts them and drops slotted content (the regression that broke
- *     `e2e-site-ui`). `__bfSlot` escapes its own plain-string path
- *     internally instead.
- */
-
-import { describe, test, expect } from 'bun:test'
-import { compileJSX } from '../compiler'
-import { TestAdapter } from '../adapters/test-adapter'
-
-const adapter = new TestAdapter()
-
-function getClientJs(source: string, filename: string): string {
-  const result = compileJSX(source, filename, { adapter })
-  expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
-  const clientJs = result.files.find(f => f.type === 'clientJs')
-  expect(clientJs).toBeDefined()
-  return clientJs!.content
-}
-
-describe('text-slot escaping', () => {
-  test('a plain text slot is wrapped in escapeTextOrMarkup (#2651)', () => {
-    const clientJs = getClientJs(
-      `'use client'
-       export function Label({ text }: { text: string }) {
-         return <span>{text}</span>
-       }`,
-      'Label.tsx',
-    )
-    expect(clientJs).toMatch(/<!--bf:\w+-->\$\{escapeTextOrMarkup\(_p\.text\)\}<!--\/-->/)
-  })
-
-  test('a branch-slot expression is NOT wrapped in escapeTextOrMarkup or escapeText', () => {
-    const clientJs = getClientJs(
-      `'use client'
-       import { createSignal } from '@barefootjs/client'
-       export function Branch({ show }: { show: boolean }) {
-         const [t] = createSignal('hi')
-         return <div>{show ? <span>{t()}</span> : null}</div>
-       }`,
-      'Branch.tsx',
-    )
-    // The branch value goes through __bfSlot (raw markers preserved)…
-    expect(clientJs).toMatch(/\$\{__bfSlot\(/)
-    // …and must never be double-wrapped by either text-escape call.
-    expect(clientJs).not.toMatch(/escapeTextOrMarkup\(\s*__bfSlot/)
-    expect(clientJs).not.toMatch(/escapeText\(\s*__bfSlot/)
-  })
-})