@barefootjs/jsx 0.18.4 → 0.18.7

package/src/__tests__/signal-init-eval.test.ts

@@ -0,0 +1,138 @@
+import { describe, test, expect } from 'bun:test'
+import { evaluateSignalInit, tryEvaluateSignalInit } from '../signal-init-eval'
+
+// #2209: replaces 7 near-duplicate regex-based `evaluateSignalInit`
+// evaluators (one per template-string adapter's test-render.ts harness)
+// with a single sandboxed real-JS evaluator. Absorbs and supersedes
+// `packages/adapter-mojolicious/src/__tests__/evaluate-signal-init.test.ts`
+// (#1672's pins) plus the actual #2209 repro shape.
+describe('evaluateSignalInit (#2209)', () => {
+  test('the #2209 repro: (props.x ?? []).map(t => ({ ...t, editing: false }))', () => {
+    const expr = `(props.initialTodos ?? []).map(t => ({ ...t, editing: false }))`
+    expect(evaluateSignalInit(expr, { initialTodos: [{ id: 1, done: false }] })).toEqual([
+      { id: 1, done: false, editing: false },
+    ])
+    expect(evaluateSignalInit(expr, undefined)).toEqual([])
+    expect(evaluateSignalInit(expr, {})).toEqual([])
+  })
+
+  test('an object-spread override applies after the spread (matches JS semantics)', () => {
+    const expr = `(props.items ?? []).map(t => ({ ...t, done: true }))`
+    expect(evaluateSignalInit(expr, { items: [{ id: 1, done: false }] })).toEqual([
+      { id: 1, done: true },
+    ])
+  })
+
+  // #1672 pins, absorbed from the deleted mojolicious-local test file.
+  test('parses an inline object-array initial value', () => {
+    expect(evaluateSignalInit(`[{ id: 'a' }, { id: 'b' }, { id: 'c' }]`)).toEqual([
+      { id: 'a' },
+      { id: 'b' },
+      { id: 'c' },
+    ])
+  })
+
+  test('parses scalar and mixed arrays, including nested objects', () => {
+    expect(evaluateSignalInit(`['x', 'y']`)).toEqual(['x', 'y'])
+    expect(evaluateSignalInit(`[1, 2, 3]`)).toEqual([1, 2, 3])
+    expect(evaluateSignalInit(`[{ id: 'a', n: 1, ok: true }]`)).toEqual([
+      { id: 'a', n: 1, ok: true },
+    ])
+  })
+
+  test('still parses scalars, empty array, and props passthrough', () => {
+    expect(evaluateSignalInit(`'b'`)).toBe('b')
+    expect(evaluateSignalInit(`5`)).toBe(5)
+    expect(evaluateSignalInit(`[]`)).toEqual([])
+    expect(evaluateSignalInit(`props.value`, { value: 42 })).toBe(42)
+  })
+
+  test('bails to null for arrays with non-literal, unbound elements', () => {
+    expect(evaluateSignalInit(`[foo(), bar]`)).toBeNull()
+  })
+
+  // Additional shapes the old regex evaluators supported.
+  test('props.x ?? default with x present, absent, or explicitly null', () => {
+    expect(evaluateSignalInit(`props.x ?? 7`, { x: 3 })).toBe(3)
+    expect(evaluateSignalInit(`props.x ?? 7`, {})).toBe(7)
+    expect(evaluateSignalInit(`props.x ?? 7`, undefined)).toBe(7)
+    // Fix over the old regex evaluators: JS `??` also falls through on an
+    // explicit `null`/`undefined` prop value — the old regex only checked
+    // `propName in props` and returned the raw (null) value, which was
+    // actually a bug relative to real JS `??` semantics.
+    expect(evaluateSignalInit(`props.x ?? 7`, { x: null })).toBe(7)
+  })
+
+  test('negative and decimal number literals', () => {
+    expect(evaluateSignalInit(`-7.6`)).toBe(-7.6)
+    expect(evaluateSignalInit(`42`)).toBe(42)
+  })
+
+  test('booleans', () => {
+    expect(evaluateSignalInit(`true`)).toBe(true)
+    expect(evaluateSignalInit(`false`)).toBe(false)
+  })
+
+  test('an explicit null initializer maps to null (the "skip" outcome)', () => {
+    expect(evaluateSignalInit(`null`)).toBeNull()
+  })
+
+  // New coverage for #2209's sandboxing contract.
+  test('blocked globals fail deterministically and fall back to null', () => {
+    expect(evaluateSignalInit(`Date.now()`)).toBeNull()
+    expect(evaluateSignalInit(`Math.random()`)).toBeNull()
+    expect(evaluateSignalInit(`typeof window`)).not.toBe('object')
+  })
+
+  test('a TS-only remnant that fails to parse as an expression falls back to null', () => {
+    expect(evaluateSignalInit(`foo as Bar`)).toBeNull()
+  })
+
+  test('a non-transportable value (class instance) falls back to null', () => {
+    expect(evaluateSignalInit(`new Set([1, 2])`)).toBeNull()
+  })
+
+  test('a bare destructured-prop identifier (not props.x) is unbound and falls back to null', () => {
+    expect(evaluateSignalInit(`count`, { count: 5 })).toBeNull()
+  })
+
+  test('tryEvaluateSignalInit distinguishes an explicit undefined from a real ok:false', () => {
+    expect(tryEvaluateSignalInit(`undefined`)).toEqual({ ok: true, value: undefined })
+    expect(tryEvaluateSignalInit(`foo()`)).toEqual({ ok: false })
+    // evaluateSignalInit's wrapper collapses both to null:
+    expect(evaluateSignalInit(`undefined`)).toBeNull()
+    expect(evaluateSignalInit(`foo()`)).toBeNull()
+  })
+
+  // Copilot review (#2229): `Function` is now shadowed too — closes the
+  // most direct bypass of the blocked-globals list.
+  test('the Function constructor is shadowed', () => {
+    expect(evaluateSignalInit(`Function('return 1')()`)).toBeNull()
+  })
+
+  // Copilot review (#2229): `isTransportable` must reject a sparse array
+  // (a hole is not the same as an element that's explicitly `undefined` —
+  // `Array.prototype.every` silently skips holes, which previously let
+  // one through undetected).
+  test('a sparse array (a hole, not an explicit undefined) falls back to null', () => {
+    // biome-ignore lint: intentional sparse-array literal for the hole test
+    expect(evaluateSignalInit(`[1, , 3]`)).toBeNull()
+  })
+
+  // Copilot review (#2229): the same object appearing twice in a
+  // non-cyclic shape (shared by reference, not by cycle) is transportable
+  // — JSON-equivalent behavior would just duplicate it — and must NOT be
+  // rejected by an overly-global "seen" set.
+  test('a shared (non-cyclic) reference is transportable', () => {
+    expect(evaluateSignalInit(`(() => { const shared = { id: 1 }; return [shared, shared] })()`)).toEqual([
+      { id: 1 },
+      { id: 1 },
+    ])
+  })
+
+  test('a genuine cycle still falls back to null', () => {
+    expect(
+      evaluateSignalInit(`(() => { const o = { id: 1 }; o.self = o; return o })()`),
+    ).toBeNull()
+  })
+})

package/src/__tests__/static-array-inner-loop-index-param.test.ts

@@ -0,0 +1,180 @@
+/**
+ * A FULLY-STATIC nested loop's inner `.map((item, i) => ...)` index param
+ * referenced in a child-component prop (#2231). Follow-up to #2218, which
+ * fixed the reactive (`mapArray`) and branch-arm paths — this covers the
+ * static-array child-init family (`plan/build-static-array-child-init.ts` /
+ * `stringify/static-array-child-init.ts`), which those fixes didn't reach
+ * because it never goes through `loopKeyFn` or the renderItem alias.
+ *
+ * Root cause: the `inner-loop-nested` shape hardcoded the synthetic
+ * `__innerIdx` as the inner `forEach`'s index param, and the
+ * `component-rooted-inner-loop` shape (#1725) declared no index params at
+ * all — so a prop getter like `get label() { return i }` threw
+ * `ReferenceError: i is not defined` on `initChild`'s first prop read at
+ * hydration.
+ *
+ * Fix: emit the user's declared index name directly as the `forEach` index
+ * param — the same idiom the outer loop has always used (`elem.index ||
+ * '__idx'`). No alias binding is needed because `forEach` supplies the real
+ * array index positionally. Loops that declare no index keep byte-identical
+ * output (`__innerIdx` fallback for `inner-loop-nested`, bare single-param
+ * heads for `component-rooted-inner-loop`).
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+function clientJsFor(source: string): string {
+  const result = compileJSX(source, 'Repro.tsx', { 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('static inner-loop index param in child-component props (#2231)', () => {
+  test('inner-loop-nested: the inner forEach binds the user index name', () => {
+    const content = clientJsFor(`
+      'use client'
+      import { Cell } from './cell'
+      const OUTER = [
+        { id: 1, subs: [{ id: 11 }, { id: 12 }] },
+        { id: 2, subs: [{ id: 21 }] },
+      ]
+      export function Repro() {
+        return (
+          <div>
+            {OUTER.map((o, oi) => (
+              <div key={o.id}>
+                {o.subs.map((sub, i) => (
+                  <Cell key={sub.id} label={i} outerPos={oi} />
+                ))}
+              </div>
+            ))}
+          </div>
+        )
+      }
+    `)
+
+    // The inner forEach's index param is the user's name, so the prop
+    // getters `return i` / `return oi` resolve.
+    expect(content).toContain('o.subs.forEach((sub, i) => {')
+    // The inner element offset indexes with the same (renamed) param.
+    expect(content).toContain('__ic.children[i]')
+    expect(content).toContain('get label() { return i }')
+    expect(content).toContain('get outerPos() { return oi }')
+    expect(content).not.toContain('__innerIdx')
+  })
+
+  test('inner-loop-nested: no declared index keeps the synthetic __innerIdx (byte stability)', () => {
+    const content = clientJsFor(`
+      'use client'
+      import { Cell } from './cell'
+      const OUTER = [
+        { id: 1, subs: [{ id: 11 }, { id: 12 }] },
+      ]
+      export function Repro() {
+        return (
+          <div>
+            {OUTER.map((o) => (
+              <div key={o.id}>
+                {o.subs.map((sub) => (
+                  <Cell key={sub.id} label={sub.id} />
+                ))}
+              </div>
+            ))}
+          </div>
+        )
+      }
+    `)
+
+    expect(content).toContain('o.subs.forEach((sub, __innerIdx) => {')
+    expect(content).toContain('__ic.children[__innerIdx]')
+  })
+
+  test('component-rooted-inner-loop: outer AND inner index params are bound', () => {
+    const content = clientJsFor(`
+      'use client'
+      import { Card, Cell } from './cell'
+      const OUTER = [
+        { id: 1, subs: [{ id: 11 }, { id: 12 }] },
+      ]
+      export function Repro2() {
+        return (
+          <div>
+            {OUTER.map((o, oi) => (
+              <Card key={o.id}>
+                {o.subs.map((sub, i) => (
+                  <Cell key={sub.id} label={i} outerPos={oi} />
+                ))}
+              </Card>
+            ))}
+          </div>
+        )
+      }
+    `)
+
+    // Document-order zip: both forEach heads carry the declared index names.
+    expect(content).toContain('OUTER.forEach((o, oi) => {')
+    expect(content).toContain('o.subs.forEach((sub, i) => {')
+    expect(content).toContain('get label() { return i }')
+    expect(content).toContain('get outerPos() { return oi }')
+  })
+
+  test('component-rooted-inner-loop: no declared index keeps bare single-param heads (byte stability)', () => {
+    const content = clientJsFor(`
+      'use client'
+      import { Card, Cell } from './cell'
+      const OUTER = [
+        { id: 1, subs: [{ id: 11 }] },
+      ]
+      export function Repro2() {
+        return (
+          <div>
+            {OUTER.map((o) => (
+              <Card key={o.id}>
+                {o.subs.map((sub) => (
+                  <Cell key={sub.id} label={sub.id} />
+                ))}
+              </Card>
+            ))}
+          </div>
+        )
+      }
+    `)
+
+    expect(content).toContain('OUTER.forEach((o) => {')
+    expect(content).toContain('o.subs.forEach((sub) => {')
+  })
+
+  test('index named like a property access is not confused (item.i stays untouched)', () => {
+    const content = clientJsFor(`
+      'use client'
+      import { Cell } from './cell'
+      const OUTER = [
+        { id: 1, subs: [{ id: 11, i: 'a' }] },
+      ]
+      export function Repro() {
+        return (
+          <div>
+            {OUTER.map((o) => (
+              <div key={o.id}>
+                {o.subs.map((sub) => (
+                  <Cell key={sub.id} label={sub.i} />
+                ))}
+              </div>
+            ))}
+          </div>
+        )
+      }
+    `)
+
+    // No index declared → synthetic param; the `sub.i` property access is
+    // untouched (this fix renames the forEach param, never rewrites bodies).
+    expect(content).toContain('o.subs.forEach((sub, __innerIdx) => {')
+    expect(content).toContain('get label() { return sub.i }')
+  })
+})

package/src/__tests__/static-literal.test.ts

@@ -0,0 +1,126 @@
+import { describe, test, expect } from 'bun:test'
+import { parseExpression } from '../expression-parser'
+import { evaluateStaticLiteral, isFullyStaticLiteral, resolveStaticLoopSource } from '../static-literal'
+import type { ConstantInfo } from '../types'
+
+// #2208: a function-scope local const whose initializer is fully known at
+// compile time (no prop/signal/function-call dependency) should bind as a
+// loop source the same way a module-scope const already does.
+describe('evaluateStaticLiteral (#2208)', () => {
+  test('scalars', () => {
+    expect(evaluateStaticLiteral(parseExpression("'Alpha'"))).toEqual({ value: 'Alpha' })
+    expect(evaluateStaticLiteral(parseExpression('42'))).toEqual({ value: 42 })
+    expect(evaluateStaticLiteral(parseExpression('true'))).toEqual({ value: true })
+    expect(evaluateStaticLiteral(parseExpression('null'))).toEqual({ value: null })
+  })
+
+  test('a no-substitution template literal', () => {
+    expect(evaluateStaticLiteral(parseExpression('`hello`'))).toEqual({ value: 'hello' })
+  })
+
+  test('a template literal whose substitutions are all static', () => {
+    expect(evaluateStaticLiteral(parseExpression("`a${1}b${'c'}`"))).toEqual({ value: 'a1bc' })
+  })
+
+  test('a template literal with a non-static substitution is not static', () => {
+    expect(evaluateStaticLiteral(parseExpression('`a${x}`'))).toBeNull()
+  })
+
+  test('nested array and object literals', () => {
+    expect(evaluateStaticLiteral(parseExpression("[{ label: 'Alpha' }, { label: 'Beta' }]"))).toEqual({
+      value: [{ label: 'Alpha' }, { label: 'Beta' }],
+    })
+    expect(evaluateStaticLiteral(parseExpression("({ a: [1, 2, { b: 'c' }] })"))).toEqual({
+      value: { a: [1, 2, { b: 'c' }] },
+    })
+  })
+
+  test('unary minus/plus/not over a static operand', () => {
+    expect(evaluateStaticLiteral(parseExpression('-5'))).toEqual({ value: -5 })
+    expect(evaluateStaticLiteral(parseExpression('+5'))).toEqual({ value: 5 })
+    expect(evaluateStaticLiteral(parseExpression('!true'))).toEqual({ value: false })
+  })
+
+  test('an empty array literal is static', () => {
+    expect(evaluateStaticLiteral(parseExpression('[]'))).toEqual({ value: [] })
+  })
+
+  test('object shorthand property is not static without bindings', () => {
+    // `{ label }` parses `label`'s value as an `identifier` — only
+    // resolvable when a caller supplies bindings for it.
+    expect(evaluateStaticLiteral(parseExpression('({ label })'))).toBeNull()
+  })
+
+  test('a call expression is not static', () => {
+    expect(evaluateStaticLiteral(parseExpression("Object.entries({ a: 1 })"))).toBeNull()
+  })
+
+  test('a props member access is not static', () => {
+    expect(evaluateStaticLiteral(parseExpression('props.tags'))).toBeNull()
+  })
+
+  test('a bare identifier resolves only through bindings', () => {
+    const expr = parseExpression('item')
+    expect(evaluateStaticLiteral(expr)).toBeNull()
+    expect(evaluateStaticLiteral(expr, new Map([['item', 'Alpha']]))).toEqual({ value: 'Alpha' })
+  })
+
+  test('a member access resolves against a bound object', () => {
+    const expr = parseExpression('item.label')
+    expect(evaluateStaticLiteral(expr, new Map([['item', { label: 'Alpha' }]]))).toEqual({ value: 'Alpha' })
+  })
+
+  test('isFullyStaticLiteral mirrors evaluateStaticLiteral', () => {
+    expect(isFullyStaticLiteral(parseExpression("[{ label: 'Alpha' }]"))).toBe(true)
+    expect(isFullyStaticLiteral(parseExpression('props.tags'))).toBe(false)
+  })
+})
+
+describe('resolveStaticLoopSource (#2208)', () => {
+  function constant(overrides: Partial<ConstantInfo>): ConstantInfo {
+    return {
+      name: 'items',
+      declarationKind: 'const',
+      type: null,
+      loc: { line: 0, column: 0 },
+      ...overrides,
+    } as ConstantInfo
+  }
+
+  test('an inline array-literal loop source resolves directly (no named local needed)', () => {
+    const result = resolveStaticLoopSource(parseExpression("[{ label: 'Alpha' }, { label: 'Beta' }]"), [])
+    expect(result).toEqual([{ label: 'Alpha' }, { label: 'Beta' }])
+  })
+
+  test('a bare identifier resolves against a FUNCTION-scope local const with a static initializer', () => {
+    const locals = [constant({ name: 'items', parsed: parseExpression("[{ label: 'Alpha' }]") })]
+    expect(resolveStaticLoopSource(parseExpression('items'), locals)).toEqual([{ label: 'Alpha' }])
+  })
+
+  test('a MODULE-scope const is excluded (handled by the existing seeding path instead)', () => {
+    const locals = [constant({ name: 'items', parsed: parseExpression("[{ label: 'Alpha' }]"), isModule: true })]
+    expect(resolveStaticLoopSource(parseExpression('items'), locals)).toBeNull()
+  })
+
+  test('a runtime-computed local const (#2069) still refuses', () => {
+    const locals = [constant({ name: 'entries', parsed: parseExpression('Object.entries(props.tags)') })]
+    expect(resolveStaticLoopSource(parseExpression('entries'), locals)).toBeNull()
+  })
+
+  test('an identifier not naming any local const refuses', () => {
+    expect(resolveStaticLoopSource(parseExpression('items'), [])).toBeNull()
+  })
+
+  test('a shadowed name is excluded via isNameShadowed', () => {
+    const locals = [constant({ name: 'items', parsed: parseExpression("[{ label: 'Alpha' }]") })]
+    const result = resolveStaticLoopSource(parseExpression('items'), locals, {
+      isNameShadowed: name => name === 'items',
+    })
+    expect(result).toBeNull()
+  })
+
+  test('a static value that is not an array refuses', () => {
+    const locals = [constant({ name: 'obj', parsed: parseExpression("{ a: 1 }") })]
+    expect(resolveStaticLoopSource(parseExpression('obj'), locals)).toBeNull()
+  })
+})

package/src/__tests__/string-concat-identifier.test.ts

@@ -0,0 +1,55 @@
+import { describe, test, expect } from 'bun:test'
+import { isStringTypedOperand, isStringConcatBinary } from '../adapters/parsed-expr-emitter'
+import { parseExpression } from '../expression-parser'
+
+// #2212: `isStringTypedOperand` gained a bare-`identifier` arm — previously
+// `a + b` where BOTH operands are plain identifiers (destructured props,
+// same-file consts) fell through every existing arm (literal, template
+// literal, zero-arg getter, `props.x` member) and was treated as numeric
+// `+`, even when both operands are string-typed. Twig/Blade/Mojolicious/
+// Xslate route a detected string-concat through their own concat operator
+// instead of native `+` (numeric-only on all four); this pins the shared
+// detection function itself, independent of any one adapter's emitter.
+describe('isStringTypedOperand identifier arm (#2212)', () => {
+  const isStr = (n: string) => n === 'first' || n === 'last'
+
+  test('a bare identifier known to be string-typed is detected', () => {
+    const expr = parseExpression('first')
+    expect(isStringTypedOperand(expr, isStr)).toBe(true)
+  })
+
+  test('a bare identifier NOT in the known-string set is not detected', () => {
+    const expr = parseExpression('count')
+    expect(isStringTypedOperand(expr, isStr)).toBe(false)
+  })
+
+  test('isStringConcatBinary(+) is true when only ONE identifier operand is string-typed', () => {
+    const parsed = parseExpression('first + count')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(true)
+  })
+
+  test('isStringConcatBinary(+) is false when NEITHER identifier operand is known string-typed', () => {
+    const parsed = parseExpression('count + total')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(false)
+  })
+
+  test('two bare-identifier string operands: first + last', () => {
+    const parsed = parseExpression('first + last')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(true)
+  })
+
+  test('a nested + chain of bare identifiers still resolves via the existing binary-recursion arm', () => {
+    const parsed = parseExpression('first + count + last')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(true)
+  })
+
+  test('a non-+ binary op is never treated as string concat regardless of operand names', () => {
+    const parsed = parseExpression('first - last')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(false)
+  })
+})