@barefootjs/jsx 0.41.0 → 0.41.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (101) hide show
  1. package/dist/adapters/attr-plan.d.ts +8 -0
  2. package/dist/adapters/attr-plan.d.ts.map +1 -1
  3. package/dist/adapters/component-props.d.ts +11 -1
  4. package/dist/adapters/component-props.d.ts.map +1 -1
  5. package/dist/adapters/computed-const.d.ts +19 -0
  6. package/dist/adapters/computed-const.d.ts.map +1 -1
  7. package/dist/adapters/dsl-template-adapter.d.ts +2 -1
  8. package/dist/adapters/dsl-template-adapter.d.ts.map +1 -1
  9. package/dist/adapters/inherited-const-server-read.d.ts +37 -0
  10. package/dist/adapters/inherited-const-server-read.d.ts.map +1 -0
  11. package/dist/adapters/loop-row-type.d.ts +18 -0
  12. package/dist/adapters/loop-row-type.d.ts.map +1 -1
  13. package/dist/adapters/non-primitive-equality.d.ts +8 -2
  14. package/dist/adapters/non-primitive-equality.d.ts.map +1 -1
  15. package/dist/adapters/number-value.d.ts +2 -1
  16. package/dist/adapters/number-value.d.ts.map +1 -1
  17. package/dist/adapters/unapplied-prop-default.d.ts +34 -0
  18. package/dist/adapters/unapplied-prop-default.d.ts.map +1 -0
  19. package/dist/adapters/uninlinable-seed-call.d.ts +29 -0
  20. package/dist/adapters/uninlinable-seed-call.d.ts.map +1 -0
  21. package/dist/analyzer.d.ts.map +1 -1
  22. package/dist/augment-inherited-props.d.ts +4 -22
  23. package/dist/augment-inherited-props.d.ts.map +1 -1
  24. package/dist/const-identity.d.ts +38 -0
  25. package/dist/const-identity.d.ts.map +1 -0
  26. package/dist/index.d.ts +10 -5
  27. package/dist/index.d.ts.map +1 -1
  28. package/dist/index.js +2500 -1475
  29. package/dist/ir-to-client-js/child-props-object.d.ts +39 -41
  30. package/dist/ir-to-client-js/child-props-object.d.ts.map +1 -1
  31. package/dist/ir-to-client-js/collect-elements.d.ts.map +1 -1
  32. package/dist/ir-to-client-js/component-scope.d.ts +13 -2
  33. package/dist/ir-to-client-js/component-scope.d.ts.map +1 -1
  34. package/dist/ir-to-client-js/control-flow/plan/build-inner-loop.d.ts.map +1 -1
  35. package/dist/ir-to-client-js/control-flow/plan/build-loop-child-arm.d.ts.map +1 -1
  36. package/dist/ir-to-client-js/html-template.d.ts.map +1 -1
  37. package/dist/ir-to-client-js/prop-handling.d.ts.map +1 -1
  38. package/dist/jsx-to-ir.d.ts.map +1 -1
  39. package/dist/local-call-body.d.ts +112 -0
  40. package/dist/local-call-body.d.ts.map +1 -0
  41. package/dist/nullable-signal-attr.d.ts +10 -0
  42. package/dist/nullable-signal-attr.d.ts.map +1 -1
  43. package/dist/prop-default-resolution.d.ts +52 -0
  44. package/dist/prop-default-resolution.d.ts.map +1 -0
  45. package/dist/props-binding.d.ts +15 -0
  46. package/dist/props-binding.d.ts.map +1 -1
  47. package/dist/server-read-walk.d.ts +66 -0
  48. package/dist/server-read-walk.d.ts.map +1 -0
  49. package/dist/ssr-defaults.d.ts.map +1 -1
  50. package/dist/ssr-seed-plan.d.ts +24 -1
  51. package/dist/ssr-seed-plan.d.ts.map +1 -1
  52. package/dist/static-const-member.d.ts +92 -0
  53. package/dist/static-const-member.d.ts.map +1 -0
  54. package/dist/types.d.ts +59 -0
  55. package/dist/types.d.ts.map +1 -1
  56. package/package.json +2 -2
  57. package/src/__tests__/computed-const.test.ts +7 -1
  58. package/src/__tests__/const-identity-child-prop.test.ts +127 -0
  59. package/src/__tests__/inherited-const-server-read.test.ts +116 -0
  60. package/src/__tests__/issue-3688-props-spread-child-csr.test.ts +8 -3
  61. package/src/__tests__/issue-3714-open-rest-spread-child.test.ts +188 -0
  62. package/src/__tests__/local-call-body.test.ts +101 -0
  63. package/src/__tests__/prop-default-resolution.test.ts +185 -0
  64. package/src/__tests__/props-spread-shadowed.test.ts +113 -0
  65. package/src/__tests__/server-read-walk.test.ts +125 -0
  66. package/src/__tests__/ssr-defaults.test.ts +67 -7
  67. package/src/__tests__/static-const-child-prop.test.ts +85 -0
  68. package/src/__tests__/static-record-literal-array.test.ts +82 -11
  69. package/src/adapters/attr-plan.ts +12 -1
  70. package/src/adapters/component-props.ts +19 -3
  71. package/src/adapters/computed-const.ts +108 -12
  72. package/src/adapters/dsl-template-adapter.ts +17 -4
  73. package/src/adapters/inherited-const-server-read.ts +174 -0
  74. package/src/adapters/loop-row-type.ts +69 -2
  75. package/src/adapters/non-primitive-equality.ts +17 -2
  76. package/src/adapters/number-value.ts +26 -2
  77. package/src/adapters/unapplied-prop-default.ts +83 -0
  78. package/src/adapters/uninlinable-seed-call.ts +62 -0
  79. package/src/analyzer.ts +43 -3
  80. package/src/augment-inherited-props.ts +4 -49
  81. package/src/compiler.ts +4 -4
  82. package/src/const-identity.ts +189 -0
  83. package/src/index.ts +10 -5
  84. package/src/ir-to-client-js/child-props-object.ts +94 -62
  85. package/src/ir-to-client-js/collect-elements.ts +28 -22
  86. package/src/ir-to-client-js/component-scope.ts +16 -2
  87. package/src/ir-to-client-js/control-flow/plan/build-inner-loop.ts +1 -0
  88. package/src/ir-to-client-js/control-flow/plan/build-loop-child-arm.ts +1 -0
  89. package/src/ir-to-client-js/html-template.ts +24 -4
  90. package/src/ir-to-client-js/index.ts +2 -2
  91. package/src/ir-to-client-js/prop-handling.ts +4 -0
  92. package/src/jsx-to-ir.ts +121 -60
  93. package/src/local-call-body.ts +191 -0
  94. package/src/nullable-signal-attr.ts +39 -17
  95. package/src/prop-default-resolution.ts +195 -0
  96. package/src/props-binding.ts +16 -0
  97. package/src/server-read-walk.ts +174 -0
  98. package/src/ssr-defaults.ts +93 -10
  99. package/src/ssr-seed-plan.ts +104 -18
  100. package/src/static-const-member.ts +243 -0
  101. package/src/types.ts +56 -0
@@ -0,0 +1,116 @@
1
+ // Which inherited literal-const reads (`R.toString`) the server render of a
2
+ // component performs (`refuseInheritedConstServerReads`), against IR built by
3
+ // the real pipeline. The rendered contract is pinned by the conformance
4
+ // fixtures `module-const-inherited-key*`.
5
+
6
+ import { describe, test, expect } from 'bun:test'
7
+ import { analyzeComponent } from '../analyzer'
8
+ import { buildMetadata } from '../compiler'
9
+ import { jsxToIR } from '../jsx-to-ir'
10
+ import { refuseInheritedConstServerReads } from '../adapters/inherited-const-server-read'
11
+ import type { CompilerError, ComponentIR } from '../types'
12
+
13
+ const R = `const R = { k: 'v' }`
14
+ const READ = `(R.toString ? 'y' : 'n')`
15
+
16
+ function irFor(body: string, preamble = ''): ComponentIR {
17
+ const ctx = analyzeComponent(`
18
+ 'use client'
19
+ import { createSignal, createMemo } from '@barefootjs/client'
20
+ function Child(props: { v?: string; f?: () => string }) { return <b>{props.v}</b> }
21
+ ${preamble}
22
+ export function C() {
23
+ ${body}
24
+ }
25
+ `, 'C.tsx', 'C')
26
+ return { version: '0.1', metadata: buildMetadata(ctx), root: jsxToIR(ctx)!, errors: [] }
27
+ }
28
+
29
+ function refused(body: string, preamble = ''): string[] {
30
+ const ir = irFor(body, preamble)
31
+ return errorsOf(ir).map(e => e.message.slice(0, e.message.indexOf(' reads ')))
32
+ }
33
+
34
+ function errorsOf(ir: ComponentIR): CompilerError[] {
35
+ const errors: CompilerError[] = []
36
+ refuseInheritedConstServerReads(ir, { errors, componentName: 'C' })
37
+ expect(errors.every(e => e.code === 'BF101')).toBe(true)
38
+ return errors
39
+ }
40
+
41
+ describe('refuseInheritedConstServerReads', () => {
42
+ test('a read in each kind of server-rendered position', () => {
43
+ expect(refused(`${R}; return <p>{${READ}}</p>`)).toEqual(['`R.toString`'])
44
+ expect(refused(`${R}; return <p data-a={R['valueOf'] ? 'y' : 'n'}>t</p>`)).toEqual(['`R.valueOf`'])
45
+ expect(refused(`${R}; return <p>{R.toString ? <b>y</b> : <i>n</i>}</p>`)).toEqual(['`R.toString`'])
46
+ expect(refused(`${R}; return <p><Child v={${READ}} /></p>`)).toEqual(['`R.toString`'])
47
+ expect(refused(`${R}; return <ul>{['a'].map(i => <li key={i}>{R.toString ? i : 'n'}</li>)}</ul>`)).toEqual(['`R.toString`'])
48
+ })
49
+
50
+ test('a read in a declaration the server render reads', () => {
51
+ expect(refused(`${R}; const [s] = createSignal(${READ}); return <p>{s()}</p>`)).toEqual(['`R.toString`'])
52
+ expect(refused(`${R}; const m = createMemo(() => ${READ}); return <p>{m()}</p>`)).toEqual(['`R.toString`'])
53
+ expect(refused(`${R}; const c = ${READ}; const m = createMemo(() => c); return <p>{m()}</p>`)).toEqual(['`R.toString`'])
54
+ expect(refused(`${R}; function value() { return ${READ} }; return <p>{value()}</p>`)).toEqual(['`R.toString`'])
55
+ expect(refused(`${R}; const m = createMemo(() => ${READ}); function value() { return m() }; return <p>{value()}</p>`)).toEqual(['`R.toString`'])
56
+ expect(refused(`return <p>{value()}</p>`, `${R}\nfunction value() { return ${READ} }`)).toEqual(['`R.toString`'])
57
+ })
58
+
59
+ test('a read only a /* @client */ position reaches is not refused', () => {
60
+ expect(refused(`${R}; return <p>{/* @client */ ${READ}}</p>`)).toEqual([])
61
+ expect(refused(`${R}; const m = createMemo(() => ${READ}); return <p>{/* @client */ m()}</p>`)).toEqual([])
62
+ expect(refused(`${R}; const [s] = createSignal(${READ}); return <p>{/* @client */ s()}</p>`)).toEqual([])
63
+ expect(refused(`${R}; function value() { return ${READ} }; return <p>{/* @client */ value()}</p>`)).toEqual([])
64
+ })
65
+
66
+ test('a loop row or callback param named like a declaration is not that declaration', () => {
67
+ expect(refused(`${R}; function value() { return ${READ} }
68
+ return <p>{['ok'].map(value => <span key={value}>{value}</span>)}{/* @client */ value()}</p>`)).toEqual([])
69
+ expect(refused(`${R}; const m = createMemo(() => ${READ})
70
+ return <p>{['ok'].map(m => <span key={m}>{m}</span>)}{/* @client */ m()}</p>`)).toEqual([])
71
+ expect(refused(`${R}; return <ul>{[{ toString: 'x' }].map(R => <li key={R.toString}>{R.toString}</li>)}</ul>`)).toEqual([])
72
+ expect(refused(`${R}; const m = createMemo(() => [{ toString: 1 }].filter(R => R.toString).length); return <p>{m()}</p>`)).toEqual([])
73
+ })
74
+
75
+ test('a function is entered where it is called, not where it is stored', () => {
76
+ const H = `const H = { safe: 'ok', get: () => ${READ} }`
77
+ expect(refused(`${R}; ${H}; return <p>{H.safe}|{/* @client */ H.get()}</p>`)).toEqual([])
78
+ expect(refused(`${R}; ${H}; const m = createMemo(() => H.safe); return <p>{m()}</p>`)).toEqual([])
79
+ expect(refused(`${R}; ${H}; return <p>{H.get()}</p>`)).toEqual(['`R.toString`'])
80
+ expect(refused(`${R}; ${H}; const m = createMemo(() => H.get()); return <p>{m()}</p>`)).toEqual(['`R.toString`'])
81
+ expect(refused(`${R}; return <p>{(() => ${READ})()}</p>`)).toEqual(['`R.toString`'])
82
+ expect(refused(`${R}; return <p><Child f={() => ${READ}} /></p>`)).toEqual([])
83
+ expect(refused(`${R}; const [s, setS] = createSignal('a'); return <button onClick={() => setS(${READ})}>{s()}</button>`)).toEqual([])
84
+ })
85
+
86
+ test('an arrow const called with arguments is entered', () => {
87
+ expect(refused(`${R}; const f = (x: string) => (R.toString ? x : 'n'); const m = createMemo(() => f('a')); return <p>{m()}</p>`)).toEqual(['`R.toString`'])
88
+ expect(refused(`${R}; const f = (R: { toString: string }) => R.toString; const m = createMemo(() => f({ toString: 'a' })); return <p>{m()}</p>`)).toEqual([])
89
+ expect(refused(`${R}; const f = (x: string) => (R.toString ? x : 'n'); const m = createMemo(() => ['a'].map(f => f).length); return <p>{m()}</p>`)).toEqual([])
90
+ })
91
+
92
+ test('a const that only names another is read as that one', () => {
93
+ expect(refused(`${R}; const A = R; const m = createMemo(() => (A.toString ? 'y' : 'n')); return <p>{m()}</p>`)).toEqual(['`R.toString`'])
94
+ expect(refused(`${R}; const A = R; const m = createMemo(() => A.k + (A.nope ?? '')); return <p>{m()}</p>`)).toEqual([])
95
+ expect(refused(`${R}; const A = R; const m = createMemo(() => ['a'].map(A => A.toString).length); return <p>{m()}</p>`)).toEqual([])
96
+ })
97
+
98
+ test('a block-bodied memo is read through the expression it folds to', () => {
99
+ expect(refused(`${R}; const m = createMemo(() => { const x = R.toString; if (x) { return 'y' } return 'n' }); return <p>{m()}</p>`)).toEqual(['`R.toString`'])
100
+ })
101
+
102
+ test('a method that calls itself ends', () => {
103
+ expect(refused(`${R}; const H = { get: () => (R.toString ? H.get() : 'n') }; return <p>{H.get()}</p>`)).toEqual(['`R.toString`'])
104
+ })
105
+
106
+ test('only a read /* @client */ can defer claims that escape', () => {
107
+ const claims = (body: string) => errorsOf(irFor(body)).map(e => e.suggestion?.escape?.map(x => x.kind) ?? [])
108
+ expect(claims(`${R}; return <p>{${READ}}</p>`)).toEqual([['client-directive']])
109
+ expect(claims(`${R}; const m = createMemo(() => ${READ}); return <p>{m()}</p>`)).toEqual([['client-directive']])
110
+ expect(claims(`${R}; return <p><Child v={${READ}} /></p>`)).toEqual([[]])
111
+ })
112
+
113
+ test('a listed or provably missing key is not refused', () => {
114
+ expect(refused(`${R}; const m = createMemo(() => R.k + (R.nope ?? '')); return <p data-a={R.nope}>{R.k}{m()}</p>`)).toEqual([])
115
+ })
116
+ })
@@ -7,7 +7,8 @@
7
7
  * props, and reads an explicit prop written before it from the caller's
8
8
  * props first in `initChild`'s `forwardProps(...)` overrides, so both merge
9
9
  * like the JSX call does. A `{...rest}` bag is not the caller's props (it
10
- * leaves out the destructured keys) and is not marked.
10
+ * leaves out the destructured keys) and is not marked; it merges without
11
+ * those keys (#3714, `issue-3714-open-rest-spread-child.test.ts`).
11
12
  *
12
13
  * The end-to-end runtime check lives in
13
14
  * `packages/client/__tests__/runtime/issue-3688-props-spread-merge.test.ts`;
@@ -130,14 +131,18 @@ describe('#3688 — the client JS merges a props-object spread in source order',
130
131
  expect(js).not.toContain(`"tone" in _p`)
131
132
  })
132
133
 
133
- test('an open rest bag stays out of the template props', () => {
134
+ test('an open rest bag is not merged as the props object', () => {
134
135
  const js = clientJs(`
135
136
  import { Tag } from './tag'
136
137
  export function Rest({ title, ...rest }: { title?: string; [key: string]: any }) {
137
138
  return <p title={title}><Tag title="x" {...rest} /></p>
138
139
  }
139
140
  `)
140
- expect(js).toContain(`renderChild('Tag', {title: "x"}`)
141
+ // The bag leaves out the destructured `title` (#3714), so the template
142
+ // spreads the caller's props without it, never `..._p`, and the explicit
143
+ // `title` written before it stays as written.
144
+ expect(js).toContain(`renderChild('Tag', {title: "x", ...forwardProps(_p, {}, ["title"])}`)
145
+ expect(js).not.toContain(`..._p`)
141
146
  expect(js).not.toContain(`"title" in _p`)
142
147
  })
143
148
  })
@@ -0,0 +1,188 @@
1
+ /**
2
+ * #3714 — an open-type `{...rest}` bag spread onto a child component in the
3
+ * client JS.
4
+ *
5
+ * The client holds the rest bag as the caller's whole props object (`_p`),
6
+ * so Phase 1 lists the caller keys the bag leaves out on the spread
7
+ * (`SpreadAttr.restOmittedKeys`): the keys the component destructured, from
8
+ * the signature or from a body destructure of the props object. Every
9
+ * reader of the bag takes them out: `initChild`'s `forwardProps(...)`, the
10
+ * registration template's `renderChild(...)` props, and `applyRestAttrs`.
11
+ *
12
+ * The rendered output is pinned by the `open-rest-spread-child*` and
13
+ * `open-body-rest-spread-*` conformance fixtures, in a real browser by
14
+ * `e2e/fixture-hydrate.playwright.ts` and `e2e/oracle.playwright.ts`.
15
+ */
16
+ import { describe, test, expect } from 'bun:test'
17
+ import { compileJSX } from '../compiler'
18
+ import { TestAdapter } from '../adapters/test-adapter'
19
+ import { analyzeComponent } from '../analyzer'
20
+ import { jsxToIR } from '../jsx-to-ir'
21
+ import type { AttrValue, IRNode } from '../types'
22
+
23
+ const adapter = new TestAdapter()
24
+
25
+ function clientJs(source: string): string {
26
+ const result = compileJSX(source, 'Repro.tsx', { adapter })
27
+ expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
28
+ return result.files.find(f => f.type === 'clientJs')!.content
29
+ }
30
+
31
+ /** Every spread value in `node`'s subtree, on elements and on component calls, in source order. */
32
+ function spreads(node: IRNode, out: AttrValue[] = []): AttrValue[] {
33
+ const attrs = node.type === 'element' ? node.attrs : node.type === 'component' ? node.props : []
34
+ for (const attr of attrs) if (attr.value.kind === 'spread') out.push(attr.value)
35
+ if (node.type === 'conditional') {
36
+ spreads(node.whenTrue, out)
37
+ spreads(node.whenFalse, out)
38
+ }
39
+ const children = 'children' in node && Array.isArray(node.children) ? (node.children as IRNode[]) : []
40
+ for (const child of children) spreads(child, out)
41
+ return out
42
+ }
43
+
44
+ function spreadsOf(source: string, componentName: string): AttrValue[] {
45
+ return spreads(jsxToIR(analyzeComponent(source, 'Repro.tsx', componentName))!)
46
+ }
47
+
48
+ const OPEN = '{ title?: string; label?: string; kind?: string; tone?: string; [key: string]: unknown }'
49
+
50
+ describe('#3714 — Phase 1 lists the keys a rest bag leaves out', () => {
51
+ test('a signature rest omits every destructured key, by its caller-facing name', () => {
52
+ const [onChild, onElement] = spreadsOf(`
53
+ import { Tag } from './tag'
54
+ export function A({ title, label: text, kind = 'k', ...rest }: ${OPEN}) {
55
+ return <p title={title} lang={text} dir={kind}><Tag {...rest} /><i {...rest} /></p>
56
+ }
57
+ `, 'A')
58
+ expect(onChild).toMatchObject({ callerBag: 'rest', restOmittedKeys: ['title', 'label', 'kind'] })
59
+ expect(onElement).toMatchObject({ callerBag: 'rest', restOmittedKeys: ['title', 'label', 'kind'] })
60
+ })
61
+
62
+ test('a body rest omits only the keys its destructure takes, through an alias too', () => {
63
+ const [direct, aliased] = spreadsOf(`
64
+ import { Tag } from './tag'
65
+ export function B(props: ${OPEN}) {
66
+ const { title, ...rest } = props
67
+ const bag = rest
68
+ return <p title={title}><Tag {...rest} /><Tag {...bag} /></p>
69
+ }
70
+ `, 'B')
71
+ expect(direct).toMatchObject({ callerBag: 'rest', restOmittedKeys: ['title'] })
72
+ expect(aliased).toMatchObject({ callerBag: 'rest', restOmittedKeys: ['title'] })
73
+ })
74
+
75
+ test('the props object and a loop row named like the rest carry no omit list', () => {
76
+ const [props] = spreadsOf(`
77
+ import { Tag } from './tag'
78
+ export function C(props: ${OPEN}) { return <p><Tag {...props} /></p> }
79
+ `, 'C')
80
+ expect(props).toMatchObject({ callerBag: 'props' })
81
+ expect(props).not.toHaveProperty('restOmittedKeys')
82
+ const [row] = spreadsOf(`
83
+ import { Tag } from './tag'
84
+ export function D({ rows, ...rest }: { rows: Array<{ tone: string }>; [key: string]: unknown }) {
85
+ return <ul>{rows.map(rest => <li><Tag {...rest} /></li>)}</ul>
86
+ }
87
+ `, 'D')
88
+ expect(row).not.toHaveProperty('callerBag')
89
+ expect(row).not.toHaveProperty('restOmittedKeys')
90
+ })
91
+ })
92
+
93
+ describe('#3714 — the client reads a rest bag without the destructured keys', () => {
94
+ const js = clientJs(`
95
+ 'use client'
96
+ import { Tag } from './tag'
97
+ export function Card({ title, label: text, items, ...rest }: { title?: string; label?: string; items: string[]; tone?: string; [key: string]: unknown }) {
98
+ return (
99
+ <div title={title} lang={text}>
100
+ <Tag {...rest} />
101
+ <Tag title="x" tone="first" {...rest} />
102
+ <Tag {...rest} tone="last" />
103
+ {title ? <Tag {...rest} /> : null}
104
+ <ul>{items.map(it => <li key={it}><Tag label={it} {...rest} /></li>)}</ul>
105
+ <i {...rest} />
106
+ </div>
107
+ )
108
+ }
109
+ `)
110
+
111
+ test('initChild forwards the bag without them, and merges in source order', () => {
112
+ // No explicit prop: only the destructured keys are held back.
113
+ expect(js).toContain(`forwardProps(_p, {}, ["title","label","items"])`)
114
+ // `title` is not in the bag, so the explicit one stays as written; the
115
+ // caller's `tone` overrides the one written before the spread.
116
+ expect(js).toContain(`forwardProps(_p, { title: "x", get tone() { return ("tone" in _p ? _p["tone"] : "first") } }, ["title","tone","label","items"])`)
117
+ // An explicit prop after the spread wins as written.
118
+ expect(js).toContain(`forwardProps(_p, { tone: "last" }, ["tone","title","label","items"])`)
119
+ })
120
+
121
+ test('a loop row and a conditional branch forward the bag too', () => {
122
+ expect(js).toContain(`upsertChild(__el, 'Tag', 's5', forwardProps(_p, { get label() { return it() } }, ["label","title","items"])`)
123
+ expect(js).toContain(`if (__c0) initChild('Tag', __c0, forwardProps(_p, {}, ["title","label","items"]))`)
124
+ })
125
+
126
+ test('the registration template spreads the bag at its source position', () => {
127
+ const bag = `...forwardProps(_p, {}, ["title","label","items"])`
128
+ expect(js).toContain(`renderChild('Tag', {${bag}}, undefined, 's0')`)
129
+ expect(js).toContain(`renderChild('Tag', {title: "x", tone: "first", ${bag}}, undefined, 's1')`)
130
+ expect(js).toContain(`renderChild('Tag', {${bag}, tone: "last"}, undefined, 's2')`)
131
+ expect(js).toContain(`renderChild('Tag', {label: it, ${bag}}, undefined, 's5')`)
132
+ })
133
+
134
+ test('an element spread keeps its exclusion list', () => {
135
+ expect(js).toContain(`applyRestAttrs(_s7, _p, ["title","label","items"])`)
136
+ })
137
+
138
+ test('a body rest holds back only the keys its destructure takes', () => {
139
+ const body = clientJs(`
140
+ 'use client'
141
+ import { Tag } from './tag'
142
+ export function Card(props: { title?: string; tone?: string; [key: string]: unknown }) {
143
+ const { title, ...rest } = props
144
+ return <div title={title}><Tag tone="first" {...rest} /><i {...rest} /></div>
145
+ }
146
+ `)
147
+ expect(body).toContain(`forwardProps(_p, { get tone() { return ("tone" in _p ? _p["tone"] : "first") } }, ["tone","title"])`)
148
+ expect(body).toContain(`renderChild('Tag', {tone: "first", ...forwardProps(_p, {}, ["title"])}, undefined, 's0')`)
149
+ expect(body).toContain(`applyRestAttrs(_s1, _p, ["title"])`)
150
+ })
151
+
152
+ test("a call that spreads a caller bag spells its JSX children as the last `children`", () => {
153
+ const kbd = (children: string, params = '{ className, children, ...rest }') => clientJs(`
154
+ 'use client'
155
+ import { Slot } from './slot'
156
+ export function Kbd(${params}: { className?: string; children?: string; [key: string]: unknown }) {
157
+ return <div><Slot className={className} {...rest}>${children}</Slot></div>
158
+ }
159
+ `)
160
+ // The bag leaves the destructured `children` out; the call's JSX
161
+ // children are written as its own entry, whatever they are.
162
+ expect(kbd('{children}')).toContain(`get children() { return children } }, ["className","children"]))`)
163
+ expect(kbd(`{children ?? 'fallback'}`)).toContain(`get children() { return children ?? 'fallback' } }, ["className","children"]))`)
164
+ expect(kbd('text')).toContain(`get children() { return "text" } }, ["className","children"]))`)
165
+ expect(kbd('<b>x</b>')).toContain('get children() { return `<b>x</b>` } }, ["className","children"]))')
166
+ // The bag carries the caller's `children`: the call's own still win,
167
+ // as an override `forwardProps` never replaces.
168
+ expect(kbd('own', '{ className, ...rest }')).toContain(`get children() { return "own" } }, ["className"]))`)
169
+ // The props object is a caller bag too.
170
+ expect(clientJs(`
171
+ 'use client'
172
+ import { Slot } from './slot'
173
+ export function Whole(props: { children?: string; [key: string]: unknown }) {
174
+ return <div><Slot {...props}>own</Slot></div>
175
+ }
176
+ `)).toContain(`initChild('Slot', _s0, forwardProps(_p, { get children() { return "own" } }, []))`)
177
+ })
178
+
179
+ test('a call without a caller bag keeps its props object as written', () => {
180
+ expect(clientJs(`
181
+ 'use client'
182
+ import { Slot } from './slot'
183
+ export function Plain({ children }: { children?: string }) {
184
+ return <div><Slot tone="a">{children}</Slot></div>
185
+ }
186
+ `)).toContain(`initChild('Slot', _s0, { tone: "a" })`)
187
+ })
188
+ })
@@ -0,0 +1,101 @@
1
+ // Which zero-argument calls a template reads as the called function's
2
+ // returned expression (`localCallBodies`) and which it refuses
3
+ // (`uninlinableLocalCalls`), against metadata built by the real pipeline. The
4
+ // rendered values are asserted by the conformance fixtures
5
+ // `memo-local-function-named-like-prop`, `signal-seed-local-function-named-like-prop`,
6
+ // `markup-local-function-named-like-prop` and `local-bindings-named-like-props`.
7
+
8
+ import { describe, test, expect } from 'bun:test'
9
+ import { analyzeComponent } from '../analyzer'
10
+ import { buildMetadata } from '../compiler'
11
+ import { localCallBodies, uninlinableLocalCalls } from '../local-call-body'
12
+ import { stringifyParsedExpr } from '../expression-parser'
13
+
14
+ function metadataFor(body: string, signature = 'props: { value?: number }', preamble = '') {
15
+ return buildMetadata(analyzeComponent(`
16
+ 'use client'
17
+ import { createSignal } from '@barefootjs/client'
18
+ ${preamble}
19
+ export function C(${signature}) {
20
+ ${body}
21
+ return <p>x</p>
22
+ }
23
+ `, 'C.tsx'))
24
+ }
25
+
26
+ function bodies(metadata: ReturnType<typeof metadataFor>): Record<string, string> {
27
+ return Object.fromEntries([...localCallBodies(metadata)].map(([name, c]) => [`${name}@${c.scope}`, stringifyParsedExpr(c.body)]))
28
+ }
29
+
30
+ describe('localCallBodies', () => {
31
+ test('a component function named like a typed prop the body never binds', () => {
32
+ expect(bodies(metadataFor('function value() { return 1 }'))).toEqual({ 'value@component': '1' })
33
+ })
34
+
35
+ test('a zero-param arrow const and a module function', () => {
36
+ const m = metadataFor('const value = () => 1', 'props: { value?: number }', "function tag() { return 'T' }")
37
+ expect(bodies(m)).toEqual({ 'value@component': '1', 'tag@module': '"T"' })
38
+ })
39
+
40
+ test('a function with a parameter or a multi-statement body is not listed', () => {
41
+ expect(bodies(metadataFor('function a(n: number) { return n } function b() { const v = 1; return v }'))).toEqual({})
42
+ })
43
+
44
+ test('a module function a destructured parameter of the same name hides', () => {
45
+ expect(bodies(metadataFor('', '{ tag }: { tag?: string }', "function tag() { return 'T' }"))).toEqual({})
46
+ })
47
+
48
+ test('a module function a body destructure of the prop hides', () => {
49
+ expect(bodies(metadataFor('const { tag } = props', 'props: { tag?: string }', "function tag() { return 'T' }"))).toEqual({})
50
+ })
51
+ })
52
+
53
+ describe('lexical resolution', () => {
54
+ // The rendered refusal is `signal-seed-uninlinable-local-function-hides-module-function`.
55
+ test('a component function a template cannot inline hides the module function of its name', () => {
56
+ const m = metadataFor('function value() { const x = 2; return x }', 'props: { value?: number }', 'function value() { return 1 }')
57
+ expect(bodies(m)).toEqual({})
58
+ expect([...uninlinableLocalCalls(m)]).toEqual(['value'])
59
+ // A module function's body still calls the module's.
60
+ expect(Object.fromEntries([...localCallBodies(m, 'module')].map(([n, c]) => [n, stringifyParsedExpr(c.body)]))).toEqual({ value: '1' })
61
+ })
62
+
63
+ test('a component arrow const with a parameter hides the module function of its name', () => {
64
+ const m = metadataFor('const value = (a?: number) => 2', 'props: { value?: number }', 'function value() { return 1 }')
65
+ expect(bodies(m)).toEqual({})
66
+ expect([...uninlinableLocalCalls(m)]).toEqual(['value'])
67
+ })
68
+
69
+ test('a function declared inside a nested function hides nothing', () => {
70
+ const m = metadataFor("function inner() { function tag() { return 'X' } return tag() }", 'props: {}', "function tag() { return 'T' }")
71
+ expect(bodies(m)['tag@module']).toBe('"T"')
72
+ })
73
+
74
+ test("a module function's call of another function is the module's, inlined in module scope", () => {
75
+ const m = metadataFor("function inner() { return 'component' }", 'props: {}', "function inner() { return 'module' } function outer() { return inner() }")
76
+ expect(bodies(m)).toEqual({ 'inner@component': '"component"', 'outer@module': '"module"' })
77
+ })
78
+
79
+ test('a module function calling one a template cannot inline is not inlinable either', () => {
80
+ const m = metadataFor('', 'props: {}', 'function inner() { const x = 1; return x } function outer() { return inner() }')
81
+ expect(bodies(m)).toEqual({})
82
+ expect([...uninlinableLocalCalls(m)].sort()).toEqual(['inner', 'outer'])
83
+ })
84
+
85
+ test('a module function calling itself is not inlinable', () => {
86
+ const m = metadataFor('', 'props: {}', 'function loop(): number { return loop() }')
87
+ expect(bodies(m)).toEqual({})
88
+ expect([...uninlinableLocalCalls(m)]).toEqual(['loop'])
89
+ })
90
+ })
91
+
92
+ describe('uninlinableLocalCalls', () => {
93
+ test('lists the functions a template cannot inline, not the ones it can', () => {
94
+ const m = metadataFor('function a(n: number) { return n } function b() { const v = 1; return v } function c() { return 1 }')
95
+ expect([...uninlinableLocalCalls(m)].sort()).toEqual(['a', 'b'])
96
+ })
97
+
98
+ test('a signal getter is not a function call to refuse', () => {
99
+ expect([...uninlinableLocalCalls(metadataFor('const [n] = createSignal(0)'))]).toEqual([])
100
+ })
101
+ })
@@ -0,0 +1,185 @@
1
+ // What a computed destructure default stands for once the declarations it
2
+ // reads are resolved (`appliedPropDefaults`), the SSR seed plan's prop steps
3
+ // built from it, and the refusal of a default no template can apply
4
+ // (`refuseUnappliedPropDefaults`), against IR built by the real pipeline.
5
+ // The rendered output is pinned by the conformance fixtures
6
+ // `destructure-default-local-const*`, `destructure-default-param-module-scope`
7
+ // and `destructure-default-reads-signal`.
8
+
9
+ import { describe, test, expect } from 'bun:test'
10
+ import { analyzeComponent } from '../analyzer'
11
+ import { buildMetadata } from '../compiler'
12
+ import { stringifyParsedExpr } from '../expression-parser'
13
+ import { jsxToIR } from '../jsx-to-ir'
14
+ import { appliedPropDefaults, computeSsrSeedPlan } from '../ssr-seed-plan'
15
+ import { refuseUnappliedPropDefaults } from '../adapters/unapplied-prop-default'
16
+ import type { CompilerError, ComponentIR } from '../types'
17
+
18
+ function irFor(body: string, signature = 'props: { a?: string; b?: string; c?: string }', preamble = ''): ComponentIR {
19
+ const ctx = analyzeComponent(`
20
+ 'use client'
21
+ import { createSignal, createMemo } from '@barefootjs/client'
22
+ function Child(props: { v?: string; onDone?: () => void }) { return <b>{props.v}</b> }
23
+ ${preamble}
24
+ export function C(${signature}) {
25
+ ${body}
26
+ }
27
+ `, 'C.tsx', 'C')
28
+ return { version: '0.1', metadata: buildMetadata(ctx), root: jsxToIR(ctx)!, errors: [] }
29
+ }
30
+
31
+ /** Each applied default as `name = <resolved>`, with `!names` for what blocks it, in application order. */
32
+ function defaults(ir: ComponentIR): string[] {
33
+ const { order, defaults } = appliedPropDefaults(ir.metadata)
34
+ return order.flatMap((p) => {
35
+ const d = defaults.get(p.name)
36
+ if (!d) return []
37
+ return [`${p.name} = ${stringifyParsedExpr(d.expr)}${d.blocked.length ? ` !${d.blocked.join(',')}` : ''}`]
38
+ })
39
+ }
40
+
41
+ /** The seed plan's prop steps, as their expression text. */
42
+ function propSteps(ir: ComponentIR): string[] {
43
+ return computeSsrSeedPlan(ir.metadata).steps.flatMap(s => (s.kind === 'derived' && s.origin === 'prop' ? [s.expr] : []))
44
+ }
45
+
46
+ function refusals(ir: ComponentIR): string[] {
47
+ const errors: CompilerError[] = []
48
+ refuseUnappliedPropDefaults(ir, { errors, componentName: 'C' })
49
+ return errors.map(e => `${e.code} ${/^The default of prop '(\w+)' reads ([^,]+(?:, '[^']+')*), which/.exec(e.message)?.slice(1).join(' <- ')}`)
50
+ }
51
+
52
+ describe('appliedPropDefaults', () => {
53
+ test('a body destructure default reads a component const, through a method, a const of a const and a function', () => {
54
+ const ir = irFor(`
55
+ const DEF = 'z'
56
+ const SUFFIX = DEF + '!'
57
+ const label = () => DEF + '?'
58
+ const { a = DEF.toUpperCase(), b = SUFFIX, c = label() } = props
59
+ return <p>{a}{b}{c}</p>`)
60
+ expect(defaults(ir)).toEqual(['a = "z".toUpperCase()', 'b = "z" + "!"', 'c = "z" + "?"'])
61
+ expect(propSteps(ir)).toEqual(['a ?? "z".toUpperCase()', 'b ?? "z" + "!"', 'c ?? "z" + "?"'])
62
+ })
63
+
64
+ test('a component const hides a module const of the same name in a body destructure default', () => {
65
+ const ir = irFor(`
66
+ const DEF = 'z'
67
+ const { a = DEF.toUpperCase(), b = DEF } = props
68
+ return <p>{a}{b}</p>`, undefined, `const DEF = 'm'`)
69
+ expect(defaults(ir)).toEqual(['a = "z".toUpperCase()', 'b = "z"'])
70
+ })
71
+
72
+ test('a parameter default reads the module const, whatever the body declares under that name', () => {
73
+ const ir = irFor(`
74
+ const DEF = 'local'
75
+ return <p>{a}{b}</p>`, `{ a = DEF.toUpperCase(), b = NEXT }: { a?: string; b?: number }`, `const DEF = 'm'\nconst START = 3\nconst NEXT = START + 1`)
76
+ expect(defaults(ir)).toEqual(['a = "m".toUpperCase()', 'b = 3 + 1'])
77
+ expect(propSteps(ir)).toEqual(['a ?? "m".toUpperCase()', 'b ?? 3 + 1'])
78
+ })
79
+
80
+ test('a module const reads the module scope where a component const has a name it reads', () => {
81
+ const ir = irFor(`
82
+ const BASE = 'local'
83
+ const { a = TAG } = props
84
+ return <p>{a}{BASE}</p>`, undefined, `const BASE = 'm'\nconst TAG = BASE + '!'`)
85
+ expect(defaults(ir)).toEqual(['a = "m" + "!"'])
86
+ })
87
+
88
+ test('a prop named like a module const is the prop', () => {
89
+ const ir = irFor(`return <p>{DEF}{b}</p>`, `{ DEF = 'p', b = DEF + '!' }: { DEF?: string; b?: string }`, `const DEF = 'm'`)
90
+ expect(defaults(ir)).toEqual(['b = DEF + "!"'])
91
+ })
92
+
93
+ test('a default reading an earlier prop through a const is applied after that prop', () => {
94
+ const ir = irFor(`
95
+ const { a = 'x'.toUpperCase() } = props
96
+ const L = a + '!'
97
+ const { b = L } = props
98
+ return <p>{a}{b}</p>`, 'props: { b?: string; a?: string }')
99
+ expect(defaults(ir)).toEqual(['a = "x".toUpperCase()', 'b = a + "!"'])
100
+ expect(propSteps(ir)).toEqual(['a ?? "x".toUpperCase()', 'b ?? a + "!"'])
101
+ })
102
+
103
+ test('a const under a callback param of a name it reads is not resolved into the callback', () => {
104
+ const ir = irFor(`
105
+ const { a = 'x'.toUpperCase() } = props
106
+ const L = a + '!'
107
+ const { b = ['p'].map(a => a + L).join('') } = props
108
+ return <p>{a}{b}</p>`)
109
+ expect(defaults(ir)[1]).toEndWith(' !L')
110
+ expect(propSteps(ir)).toEqual(['a ?? "x".toUpperCase()'])
111
+ })
112
+
113
+ test('a const declared after the destructure is not initialized when the default runs', () => {
114
+ const ir = irFor(`
115
+ const { a = DEF, b = EARLY } = props
116
+ const DEF = 'z'
117
+ return <p>{a}{b}</p>`, undefined, `const DEF = 'm'\nconst EARLY = 'e'`)
118
+ expect(defaults(ir)).toEqual(['a = DEF !DEF', 'b = "e"'])
119
+ expect(propSteps(ir)).toEqual(['b ?? "e"'])
120
+ })
121
+
122
+ test('a signal, a memo, a let, a reassigned const and a function with a parameter block the default', () => {
123
+ const ir = irFor(`
124
+ const [s] = createSignal('q')
125
+ const m = createMemo(() => s() + '!')
126
+ let n = 'n'
127
+ function fmt(x: string) { return x }
128
+ const L = s() + '!'
129
+ const { a = L, b = m() + n, c = fmt('x') } = props
130
+ return <p>{a}{b}{c}</p>`)
131
+ expect(defaults(ir)).toEqual(['a = s() + "!" !s', 'b = m() + n !m,n', 'c = fmt("x") !fmt'])
132
+ expect(propSteps(ir)).toEqual([])
133
+ })
134
+ })
135
+
136
+ describe('refuseUnappliedPropDefaults', () => {
137
+ const BLOCKED = `
138
+ const [s] = createSignal('q')
139
+ const L = s() + '!'
140
+ const { a = L, b = a } = props`
141
+
142
+ test('a blocked default is refused where a position reads the prop', () => {
143
+ expect(refusals(irFor(`${BLOCKED}
144
+ return <p>{a}</p>`))).toEqual([`BF101 a <- 's'`])
145
+ })
146
+
147
+ test('through a signal seed, a memo, a child prop and another prop default', () => {
148
+ expect(refusals(irFor(`${BLOCKED}
149
+ const [n] = createSignal(a)
150
+ return <p>{n()}</p>`))).toEqual([`BF101 a <- 's'`])
151
+ expect(refusals(irFor(`${BLOCKED}
152
+ const m = createMemo(() => a + '?')
153
+ return <p>{m()}</p>`))).toEqual([`BF101 a <- 's'`])
154
+ expect(refusals(irFor(`${BLOCKED}
155
+ return <Child v={a} />`))).toEqual([`BF101 a <- 's'`])
156
+ expect(refusals(irFor(`${BLOCKED}
157
+ return <p>{b}</p>`))).toEqual([`BF101 a <- 's'`])
158
+ })
159
+
160
+ test('not where only the client reads the prop', () => {
161
+ expect(refusals(irFor(`${BLOCKED}
162
+ return <p>{/* @client */ a}</p>`))).toEqual([])
163
+ expect(refusals(irFor(`${BLOCKED}
164
+ return <button onClick={() => console.log(a)}>x</button>`))).toEqual([])
165
+ })
166
+
167
+ test('claims the /* @client */ escape unless a child prop reads the prop', () => {
168
+ const claims = (body: string) => {
169
+ const errors: CompilerError[] = []
170
+ refuseUnappliedPropDefaults(irFor(body), { errors, componentName: 'C' })
171
+ return errors.map(e => e.suggestion?.escape?.map(x => x.kind) ?? [])
172
+ }
173
+ expect(claims(`${BLOCKED}
174
+ return <p>{a}</p>`)).toEqual([['client-directive']])
175
+ expect(claims(`${BLOCKED}
176
+ return <p>{a}<Child v={b} /></p>`)).toEqual([[]])
177
+ })
178
+
179
+ test('a handler default naming a component function is not refused', () => {
180
+ expect(refusals(irFor(`
181
+ function handleDone() {}
182
+ const { onDone = handleDone } = props
183
+ return <div><button onClick={onDone}>x</button><Child onDone={onDone} /></div>`, 'props: { onDone?: () => void }'))).toEqual([])
184
+ })
185
+ })