@barefootjs/jsx 0.39.7 → 0.39.8

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 (146) hide show
  1. package/dist/adapters/callback-method.d.ts +17 -0
  2. package/dist/adapters/callback-method.d.ts.map +1 -1
  3. package/dist/adapters/component-props.d.ts +80 -13
  4. package/dist/adapters/component-props.d.ts.map +1 -1
  5. package/dist/adapters/dsl-template-adapter.d.ts +151 -0
  6. package/dist/adapters/dsl-template-adapter.d.ts.map +1 -0
  7. package/dist/adapters/jsx-adapter.d.ts +4 -0
  8. package/dist/adapters/jsx-adapter.d.ts.map +1 -1
  9. package/dist/adapters/literal-value.d.ts +2 -2
  10. package/dist/adapters/literal-value.d.ts.map +1 -1
  11. package/dist/adapters/parsed-expr-emitter.d.ts +27 -0
  12. package/dist/adapters/parsed-expr-emitter.d.ts.map +1 -1
  13. package/dist/adapters/style-object.d.ts +33 -0
  14. package/dist/adapters/style-object.d.ts.map +1 -0
  15. package/dist/analyzer.d.ts.map +1 -1
  16. package/dist/children-nullish.d.ts +22 -0
  17. package/dist/children-nullish.d.ts.map +1 -0
  18. package/dist/errors.d.ts +1 -0
  19. package/dist/errors.d.ts.map +1 -1
  20. package/dist/expression-parser.d.ts +9 -19
  21. package/dist/expression-parser.d.ts.map +1 -1
  22. package/dist/free-refs.d.ts +6 -0
  23. package/dist/free-refs.d.ts.map +1 -1
  24. package/dist/index.d.ts +14 -11
  25. package/dist/index.d.ts.map +1 -1
  26. package/dist/index.js +14685 -14000
  27. package/dist/ir-to-client-js/compute-inlinability.d.ts.map +1 -1
  28. package/dist/ir-to-client-js/control-flow/plan/event-collision.d.ts +2 -1
  29. package/dist/ir-to-client-js/control-flow/plan/event-collision.d.ts.map +1 -1
  30. package/dist/ir-to-client-js/control-flow/plan/insert.d.ts +2 -2
  31. package/dist/ir-to-client-js/control-flow/plan/insert.d.ts.map +1 -1
  32. package/dist/ir-to-client-js/control-flow/stringify/event-delegation.d.ts.map +1 -1
  33. package/dist/ir-to-client-js/control-flow/stringify/event-listener.d.ts +10 -9
  34. package/dist/ir-to-client-js/control-flow/stringify/event-listener.d.ts.map +1 -1
  35. package/dist/ir-to-client-js/csr-substitute.d.ts.map +1 -1
  36. package/dist/ir-to-client-js/emit-reactive.d.ts +1 -1
  37. package/dist/ir-to-client-js/emit-reactive.d.ts.map +1 -1
  38. package/dist/ir-to-client-js/emit-registration.d.ts +10 -8
  39. package/dist/ir-to-client-js/emit-registration.d.ts.map +1 -1
  40. package/dist/ir-to-client-js/generate-init.d.ts.map +1 -1
  41. package/dist/ir-to-client-js/html-template.d.ts +0 -9
  42. package/dist/ir-to-client-js/html-template.d.ts.map +1 -1
  43. package/dist/ir-to-client-js/identifiers.d.ts +6 -8
  44. package/dist/ir-to-client-js/identifiers.d.ts.map +1 -1
  45. package/dist/ir-to-client-js/imports.d.ts +23 -2
  46. package/dist/ir-to-client-js/imports.d.ts.map +1 -1
  47. package/dist/ir-to-client-js/phases/props-extraction.d.ts +3 -2
  48. package/dist/ir-to-client-js/phases/props-extraction.d.ts.map +1 -1
  49. package/dist/ir-to-client-js/prune-unused-prop-extractions.d.ts +1 -1
  50. package/dist/ir-to-client-js/prune-unused-prop-extractions.d.ts.map +1 -1
  51. package/dist/ir-to-client-js/reactivity.d.ts.map +1 -1
  52. package/dist/ir-to-client-js/rewrite-destructured-props.d.ts +1 -1
  53. package/dist/ir-to-client-js/rewrite-destructured-props.d.ts.map +1 -1
  54. package/dist/ir-to-client-js/safe-html.d.ts +20 -2
  55. package/dist/ir-to-client-js/safe-html.d.ts.map +1 -1
  56. package/dist/ir-to-client-js/types.d.ts +3 -3
  57. package/dist/ir-to-client-js/types.d.ts.map +1 -1
  58. package/dist/ir-to-client-js/utils.d.ts +2 -11
  59. package/dist/ir-to-client-js/utils.d.ts.map +1 -1
  60. package/dist/jsx-to-ir.d.ts.map +1 -1
  61. package/dist/nullable-signal-attr.d.ts +40 -10
  62. package/dist/nullable-signal-attr.d.ts.map +1 -1
  63. package/dist/prop-rewrite.d.ts +18 -0
  64. package/dist/prop-rewrite.d.ts.map +1 -1
  65. package/dist/props-binding.d.ts +9 -1
  66. package/dist/props-binding.d.ts.map +1 -1
  67. package/dist/scanner/js-scanner.d.ts.map +1 -1
  68. package/dist/scanner/js-scanner.js +30 -2
  69. package/dist/signal-prop-name-collision.d.ts +6 -5
  70. package/dist/signal-prop-name-collision.d.ts.map +1 -1
  71. package/dist/ssr-defaults.d.ts +28 -0
  72. package/dist/ssr-defaults.d.ts.map +1 -1
  73. package/dist/ssr-seed-plan.d.ts +39 -14
  74. package/dist/ssr-seed-plan.d.ts.map +1 -1
  75. package/dist/types.d.ts +108 -18
  76. package/dist/types.d.ts.map +1 -1
  77. package/dist/value-references.d.ts +21 -0
  78. package/dist/value-references.d.ts.map +1 -1
  79. package/package.json +2 -2
  80. package/src/__tests__/__snapshots__/doc-examples.test.ts.snap +18 -18
  81. package/src/__tests__/adapter-output.test.ts +5 -3
  82. package/src/__tests__/analyzer.test.ts +33 -0
  83. package/src/__tests__/arithmetic-lowering.test.ts +44 -0
  84. package/src/__tests__/children-read.test.ts +226 -0
  85. package/src/__tests__/client-template-escape-soundness.test.ts +31 -1
  86. package/src/__tests__/component-props.test.ts +68 -1
  87. package/src/__tests__/constant-inlining-tree.test.ts +136 -0
  88. package/src/__tests__/destructure-default-reads-earlier-param.test.ts +138 -0
  89. package/src/__tests__/dsl-template-adapter.test.ts +173 -0
  90. package/src/__tests__/event-handler-verbatim.test.ts +73 -0
  91. package/src/__tests__/expression-parser.test.ts +1 -44
  92. package/src/__tests__/nullable-signal-attr.test.ts +67 -3
  93. package/src/__tests__/reference-graph-identifiers.test.ts +161 -0
  94. package/src/__tests__/runtime-import-detection.test.ts +134 -0
  95. package/src/__tests__/signal-prop-name-collision.test.ts +30 -0
  96. package/src/__tests__/ssr-defaults.test.ts +19 -1
  97. package/src/__tests__/ssr-seed-plan.test.ts +119 -0
  98. package/src/__tests__/style-object-plan.test.ts +54 -0
  99. package/src/__tests__/zero-param-helper-inline.test.ts +57 -0
  100. package/src/adapters/callback-method.ts +23 -0
  101. package/src/adapters/component-props.ts +130 -12
  102. package/src/adapters/dsl-template-adapter.ts +248 -0
  103. package/src/adapters/jsx-adapter.ts +12 -6
  104. package/src/adapters/literal-value.ts +2 -2
  105. package/src/adapters/parsed-expr-emitter.ts +34 -0
  106. package/src/adapters/style-object.ts +61 -0
  107. package/src/analyzer.ts +114 -15
  108. package/src/children-nullish.ts +33 -0
  109. package/src/debug.ts +2 -2
  110. package/src/errors.ts +12 -0
  111. package/src/expression-parser.ts +56 -53
  112. package/src/free-refs.ts +28 -17
  113. package/src/index.ts +18 -8
  114. package/src/ir-to-client-js/compute-inlinability.ts +29 -2
  115. package/src/ir-to-client-js/control-flow/plan/event-collision.ts +2 -1
  116. package/src/ir-to-client-js/control-flow/plan/insert.ts +2 -2
  117. package/src/ir-to-client-js/control-flow/stringify/event-delegation.ts +3 -2
  118. package/src/ir-to-client-js/control-flow/stringify/event-listener.ts +13 -12
  119. package/src/ir-to-client-js/csr-substitute.ts +12 -2
  120. package/src/ir-to-client-js/emit-reactive.ts +2 -2
  121. package/src/ir-to-client-js/emit-registration.ts +28 -57
  122. package/src/ir-to-client-js/generate-init.ts +17 -1
  123. package/src/ir-to-client-js/html-template.ts +30 -50
  124. package/src/ir-to-client-js/identifiers.ts +75 -24
  125. package/src/ir-to-client-js/imports.ts +56 -19
  126. package/src/ir-to-client-js/index.ts +2 -1
  127. package/src/ir-to-client-js/phases/event-handlers.ts +2 -2
  128. package/src/ir-to-client-js/phases/props-extraction.ts +16 -15
  129. package/src/ir-to-client-js/plan/build-declaration-emit.ts +2 -2
  130. package/src/ir-to-client-js/prune-unused-prop-extractions.ts +7 -4
  131. package/src/ir-to-client-js/reactivity.ts +2 -2
  132. package/src/ir-to-client-js/rewrite-destructured-props.ts +21 -4
  133. package/src/ir-to-client-js/safe-html.ts +29 -35
  134. package/src/ir-to-client-js/types.ts +3 -2
  135. package/src/ir-to-client-js/utils.ts +2 -26
  136. package/src/jsx-to-ir.ts +279 -78
  137. package/src/nullable-signal-attr.ts +149 -33
  138. package/src/prop-rewrite.ts +41 -0
  139. package/src/props-binding.ts +17 -2
  140. package/src/scanner/__tests__/js-scanner.test.ts +37 -0
  141. package/src/scanner/js-scanner.ts +64 -4
  142. package/src/signal-prop-name-collision.ts +50 -24
  143. package/src/ssr-defaults.ts +47 -20
  144. package/src/ssr-seed-plan.ts +103 -23
  145. package/src/types.ts +115 -19
  146. package/src/value-references.ts +132 -0
@@ -0,0 +1,138 @@
1
+ /**
2
+ * A props destructure default that reads an earlier binding of its own
3
+ * pattern (`{ off = false, on = off }`, #3531). The analyzer splits the
4
+ * default at those reads (`ParamInfo.defaultParts`), and the client JS
5
+ * renders each as the earlier prop's own live read, so no emitted scope
6
+ * names a binding it lacks.
7
+ */
8
+
9
+ import { describe, test, expect } from 'bun:test'
10
+ import { analyzeComponent } from '../analyzer'
11
+ import { compileJSX } from '../compiler'
12
+ import { TestAdapter } from '../adapters/test-adapter'
13
+ import { splitScopedValueRefs } from '../prop-rewrite'
14
+
15
+ const adapter = new TestAdapter()
16
+
17
+ function clientJs(source: string): string {
18
+ const result = compileJSX(source, 'Component.tsx', { adapter })
19
+ expect(result.errors.filter(e => e.severity === 'error')).toEqual([])
20
+ const file = result.files.find(f => f.type === 'clientJs')
21
+ expect(file).toBeDefined()
22
+ return file!.content
23
+ }
24
+
25
+ function propsParams(source: string) {
26
+ return analyzeComponent(source, 'Component.tsx').propsParams
27
+ }
28
+
29
+ describe('ParamInfo.defaultParts', () => {
30
+ test('records each read of an earlier binding, carrying its own read for a chain', () => {
31
+ const params = propsParams(`
32
+ function C({ a = 'x', b = a, c = b }: { a?: string; b?: string; c?: string }) {
33
+ return <p>{c}</p>
34
+ }
35
+ `)
36
+ const byName = new Map(params.map(p => [p.name, p]))
37
+ expect(byName.get('a')!.defaultParts).toBeUndefined()
38
+ expect(byName.get('b')!.defaultParts).toEqual([
39
+ { kind: 'param', param: { name: 'a', defaultValue: "'x'" } },
40
+ ])
41
+ const cParts = byName.get('c')!.defaultParts!
42
+ expect(cParts).toHaveLength(1)
43
+ expect(cParts[0]).toEqual({ kind: 'param', param: { name: 'b', defaultValue: 'a', defaultParts: byName.get('b')!.defaultParts } })
44
+ })
45
+
46
+ test('leaves a later binding (TDZ), an outer name and a shadowing callback param alone', () => {
47
+ const params = propsParams(`
48
+ const off = true
49
+ function C({ first = later, x = 1, y = [1].map((x) => x + 1), later = 2 }: { first?: number; x?: number; y?: number[]; later?: number }) {
50
+ return <p>{first}{y}</p>
51
+ }
52
+ `)
53
+ for (const p of params) expect(p.defaultParts).toBeUndefined()
54
+ })
55
+
56
+ test('keeps a shorthand property key as text', () => {
57
+ expect(splitScopedValueRefs('{ off, n: off }', new Set(['off']))).toEqual([
58
+ { kind: 'text', text: '{ off: ' },
59
+ { kind: 'ref', name: 'off' },
60
+ { kind: 'text', text: ', n: ' },
61
+ { kind: 'ref', name: 'off' },
62
+ { kind: 'text', text: ' }' },
63
+ ])
64
+ })
65
+ })
66
+
67
+ describe('client JS reads the earlier prop live', () => {
68
+ test('parameter form: the default reads the earlier prop with its own default', () => {
69
+ const js = clientJs(`
70
+ 'use client'
71
+ export function C({ off = false, on = off }: { off?: boolean; on?: boolean }) {
72
+ return <p>{String(on && true)}</p>
73
+ }
74
+ `)
75
+ expect(js).toContain('(_p.on ?? (_p.off ?? false))')
76
+ expect(js).not.toContain('_p.on ?? off)')
77
+ })
78
+
79
+ test('a chain nests each earlier read, and an expression default keeps its operator', () => {
80
+ const js = clientJs(`
81
+ 'use client'
82
+ export function C({ a = 'x', b = a, c = b, off = false, on = !off }: { a?: string; b?: string; c?: string; off?: boolean; on?: boolean }) {
83
+ return <p>{c}{String(on)}</p>
84
+ }
85
+ `)
86
+ expect(js).toContain(`(_p.c ?? (_p.b ?? (_p.a ?? 'x')))`)
87
+ expect(js).toContain('(_p.on ?? !(_p.off ?? false))')
88
+ })
89
+
90
+ test('a renamed earlier binding reads its caller-facing key', () => {
91
+ const js = clientJs(`
92
+ 'use client'
93
+ export function C({ off: o = false, on = o }: { off?: boolean; on?: boolean }) {
94
+ return <p>{String(on)}</p>
95
+ }
96
+ `)
97
+ expect(js).toContain('(_p.on ?? (_p.off ?? false))')
98
+ })
99
+
100
+ test('body form: the init body reads the earlier prop live too', () => {
101
+ const js = clientJs(`
102
+ 'use client'
103
+ export function C(props: { off?: boolean; on?: boolean }) {
104
+ const { off = false, on = off } = props
105
+ return <p>{String(on)}</p>
106
+ }
107
+ `)
108
+ expect(js).not.toMatch(/_p\.on \?\? off\b/)
109
+ expect(js).toContain('(_p.on ?? (_p.off ?? false))')
110
+ })
111
+
112
+ test('the CSR template reads a signal seed and a memo over the prop with its default', () => {
113
+ const js = clientJs(`
114
+ 'use client'
115
+ import { createSignal, createMemo } from '@barefootjs/client'
116
+ export function C({ off = false, on = off }: { off?: boolean; on?: boolean }) {
117
+ const [v, setV] = createSignal(on)
118
+ const flipped = createMemo(() => !on)
119
+ return <p onClick={() => setV(!v())}>{String(v())}|{String(flipped())}</p>
120
+ }
121
+ `)
122
+ const template = js.slice(js.indexOf('template: (_p) =>'))
123
+ expect(template).toContain('String(((_p.on ?? (_p.off ?? false))))')
124
+ expect(template).toContain('String((!(_p.on ?? (_p.off ?? false))))')
125
+ })
126
+
127
+ test('a controlled signal seeded by the prop reads the earlier prop live', () => {
128
+ const js = clientJs(`
129
+ 'use client'
130
+ import { createSignal } from '@barefootjs/client'
131
+ export function C({ off = false, on = off }: { off?: boolean; on?: boolean }) {
132
+ const [v, setV] = createSignal(on)
133
+ return <button onClick={() => setV(!v())}>{String(v())}</button>
134
+ }
135
+ `)
136
+ expect(js).not.toMatch(/_p\.on \?\? off\b/)
137
+ })
138
+ })
@@ -0,0 +1,173 @@
1
+ import { describe, test, expect } from 'bun:test'
2
+ import { analyzeComponent } from '../analyzer'
3
+ import { jsxToIR } from '../jsx-to-ir'
4
+ import { buildMetadata } from '../compiler'
5
+ import { DslTemplateAdapter, type TemplateIdentifierSpelling } from '../adapters/dsl-template-adapter'
6
+ import type {
7
+ ComponentIR,
8
+ IRComponent,
9
+ IRConditional,
10
+ IRElement,
11
+ IRExpression,
12
+ IRIfStatement,
13
+ IRLoop,
14
+ IRNode,
15
+ } from '../types'
16
+
17
+ // #3475: the `generate()` the eight DSL template adapters share. A minimal
18
+ // adapter stands in for one; each hook records what it saw.
19
+ function componentIR(source: string): ComponentIR {
20
+ const ctx = analyzeComponent(source, 'Test.tsx')
21
+ const root = jsxToIR(ctx)
22
+ if (!root) throw new Error('expected IR')
23
+ return { version: '0.1', metadata: buildMetadata(ctx), root, errors: [] }
24
+ }
25
+
26
+ class StubAdapter extends DslTemplateAdapter {
27
+ name = 'stub'
28
+ extension = '.stub'
29
+ protected readonly loopChildDiagnosticName = 'Stub'
30
+ protected override readonly templateIdentifierSpelling: TemplateIdentifierSpelling | null
31
+ /** What `resetAdapterState` saw of the shared state. */
32
+ seenAtReset: { propNames: string[]; errors: number; counter: number } | null = null
33
+ scriptCalls: unknown[][] = []
34
+
35
+ constructor(spelling: TemplateIdentifierSpelling | null = null) {
36
+ super()
37
+ this.templateIdentifierSpelling = spelling
38
+ }
39
+
40
+ protected stringValueNamesFor(): Set<string> {
41
+ return new Set()
42
+ }
43
+ protected override resetAdapterState(): void {
44
+ this.seenAtReset = {
45
+ propNames: this.propsParams.map(p => p.name),
46
+ errors: this.errors.length,
47
+ counter: this.childrenCaptureCounter,
48
+ }
49
+ }
50
+ protected renderIfStatement(ifStmt: IRIfStatement): string {
51
+ return `[if ${ifStmt.condition}]`
52
+ }
53
+ protected generateScriptRegistrations(...args: unknown[]): string {
54
+ this.scriptCalls.push(args.slice(1))
55
+ return '[scripts]'
56
+ }
57
+ protected contextConsumerSeed(): string {
58
+ return '[ctx]'
59
+ }
60
+ protected derivedMemoSeed(): string {
61
+ return '[memo]'
62
+ }
63
+
64
+ renderNode(node: IRNode): string {
65
+ if (node.type === 'component') {
66
+ // A rendering diagnostic, and a use of the per-compile counter.
67
+ this.errors.push({
68
+ code: 'BF999',
69
+ severity: 'error',
70
+ message: `rendered ${(node as IRComponent).name}`,
71
+ loc: { file: 'Test.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
72
+ })
73
+ return `[child ${this.childrenCaptureCounter++}]`
74
+ }
75
+ if (node.type === 'element') return `<${(node as IRElement).tag}>${this.renderChildren((node as IRElement).children)}`
76
+ if (node.type === 'loop') return this.renderChildren((node as IRLoop).children)
77
+ return `{${node.type}}`
78
+ }
79
+ renderElement(element: IRElement): string {
80
+ return this.renderNode(element)
81
+ }
82
+ renderExpression(expr: IRExpression): string {
83
+ return this.renderNode(expr)
84
+ }
85
+ renderConditional(cond: IRConditional): string {
86
+ return this.renderNode(cond)
87
+ }
88
+ renderLoop(loop: IRLoop): string {
89
+ return this.renderNode(loop)
90
+ }
91
+ renderComponent(comp: IRComponent): string {
92
+ return this.renderNode(comp)
93
+ }
94
+ renderScopeMarker(): string {
95
+ return ''
96
+ }
97
+ renderSlotMarker(): string {
98
+ return ''
99
+ }
100
+ renderCondMarker(): string {
101
+ return ''
102
+ }
103
+ }
104
+
105
+ const LOOP_CHILD = `
106
+ import Child from './child'
107
+ export function Test({ items }: { items: string[] }) {
108
+ return <ul>{items.map(i => <Child key={i} />)}</ul>
109
+ }
110
+ `
111
+
112
+ describe('DslTemplateAdapter.generate (#3475)', () => {
113
+ test('the template is the script registrations, the two seeds and the body, in that order', () => {
114
+ const out = new StubAdapter().generate(componentIR(`export function Test() { return <p>hi</p> }`))
115
+ expect(out.template).toBe('[scripts][ctx][memo]<p>{text}\n')
116
+ expect(out.sections).toEqual({ imports: '', types: '', component: out.template, defaultExport: '' })
117
+ expect(out.extension).toBe('.stub')
118
+ })
119
+
120
+ test('skipScriptRegistration drops the registrations; the script options reach the adapter', () => {
121
+ const ir = componentIR(`export function Test() { return <p>hi</p> }`)
122
+ const adapter = new StubAdapter()
123
+ expect(adapter.generate(ir, { skipScriptRegistration: true }).template).toBe('[ctx][memo]<p>{text}\n')
124
+ adapter.generate(ir, { scriptBaseName: 'Base', scriptAssets: ['/a.js'], preloadAssets: ['/p.js'] })
125
+ expect(adapter.scriptCalls).toEqual([['Base', ['/a.js'], ['/p.js']]])
126
+ })
127
+
128
+ test('a root if statement renders through renderIfStatement', () => {
129
+ const ir = componentIR(`
130
+ export function Test({ on }: { on: boolean }) {
131
+ if (on) return <p>on</p>
132
+ return <p>off</p>
133
+ }
134
+ `)
135
+ expect(ir.root.type).toBe('if-statement')
136
+ expect(new StubAdapter().generate(ir, { skipScriptRegistration: true }).template).toBe('[ctx][memo][if on]\n')
137
+ })
138
+
139
+ test('the adapter hook runs after the shared state is reset', () => {
140
+ const adapter = new StubAdapter()
141
+ adapter.generate(componentIR(LOOP_CHILD))
142
+ adapter.generate(componentIR(`export function Test({ label }: { label: string }) { return <p>{label}</p> }`))
143
+ expect(adapter.seenAtReset).toEqual({ propNames: ['label'], errors: 0, counter: 0 })
144
+ })
145
+
146
+ test('BF103 names the adapter, comes before rendering diagnostics, and is suppressed for registered siblings', () => {
147
+ const ir = componentIR(LOOP_CHILD)
148
+ const out = new StubAdapter().generate(ir)
149
+ expect(out.template).toContain('[child 0]')
150
+ expect(ir.errors.map(e => e.code)).toEqual(['BF103', 'BF999'])
151
+ expect(ir.errors[0]!.message).toContain('The Stub adapter emits')
152
+
153
+ const registered = componentIR(LOOP_CHILD)
154
+ new StubAdapter().generate(registered, { siblingTemplatesRegistered: true })
155
+ expect(registered.errors.map(e => e.code)).toEqual(['BF999'])
156
+ })
157
+
158
+ test('the reserved-name collision check runs only for an adapter that renames names', () => {
159
+ const source = `
160
+ export function Test(props: { loop: string; __bf_loop: string }) {
161
+ return <div>{props.loop}{props.__bf_loop}</div>
162
+ }
163
+ `
164
+ const spelling = { ident: (name: string) => (name === 'loop' ? '__bf_loop' : name), label: 'Stub' }
165
+ const renamed = componentIR(source)
166
+ new StubAdapter(spelling).generate(renamed)
167
+ expect(renamed.errors.map(e => e.code)).toEqual(['BF105'])
168
+
169
+ const plain = componentIR(source)
170
+ new StubAdapter().generate(plain)
171
+ expect(plain.errors).toEqual([])
172
+ })
173
+ })
@@ -0,0 +1,73 @@
1
+ /**
2
+ * Event handlers reach `addEventListener` verbatim (#3538).
3
+ *
4
+ * The emitters used to rewrite an arrow handler into block form by splitting
5
+ * its text at the first `=>`, which broke any handler whose first `=>` is not
6
+ * the outer arrow's (a conditional choosing between arrows, a default
7
+ * parameter holding an arrow). `addEventListener` ignores a listener's return
8
+ * value, so the handler is now passed through as written, in every position
9
+ * a listener is emitted from.
10
+ */
11
+
12
+ import { describe, test, expect } from 'bun:test'
13
+ import { compileJSX } from '../compiler'
14
+ import { TestAdapter } from '../adapters/test-adapter'
15
+
16
+ const adapter = new TestAdapter()
17
+ const transpiler = new Bun.Transpiler({ loader: 'js' })
18
+
19
+ const HANDLERS: Record<string, string> = {
20
+ 'conditional between arrows': '(n() > 5 ? () => setN(0) : () => setN(n() + 1))',
21
+ 'default parameter holding an arrow': '(e = { step: () => 2 }) => setN(n() + e.step())',
22
+ 'comma sequence': 'setN(1), () => setN(n() + 1)',
23
+ 'destructured parameter': '({ currentTarget }) => setN(currentTarget ? n() + 1 : 0)',
24
+ 'expression-bodied arrow': '() => setN(n() + 1)',
25
+ }
26
+
27
+ /** Wraps one handler in each position a listener is emitted from. */
28
+ function positions(handler: string): Record<string, string> {
29
+ return {
30
+ 'top-level element': `<button onClick={${handler}}>{n()}</button>`,
31
+ 'conditional branch': `<div>{n() > 0 ? <button onClick={${handler}}>a</button> : <span>none</span>}</div>`,
32
+ 'loop row': `<ul>{items().map(item => <li key={item}><button onClick={${handler}}>{item}</button></li>)}</ul>`,
33
+ }
34
+ }
35
+
36
+ function compile(body: string): string {
37
+ const source = `
38
+ 'use client'
39
+ import { createSignal } from '@barefootjs/client'
40
+ export function T() {
41
+ const [n, setN] = createSignal(0)
42
+ const [items] = createSignal(['a', 'b'])
43
+ return ${body}
44
+ }
45
+ `
46
+ const result = compileJSX(source, 'T.tsx', { adapter })
47
+ expect(result.errors).toHaveLength(0)
48
+ const clientJs = result.files.find(f => f.type === 'clientJs')
49
+ expect(clientJs).toBeDefined()
50
+ return clientJs!.content
51
+ }
52
+
53
+ describe('event handlers are emitted verbatim (#3538)', () => {
54
+ for (const [shape, handler] of Object.entries(HANDLERS)) {
55
+ for (const [position, body] of Object.entries(positions(handler))) {
56
+ test(`${shape} in a ${position} compiles to valid JS`, () => {
57
+ const js = compile(body)
58
+ expect(() => transpiler.transformSync(js)).not.toThrow()
59
+ })
60
+ }
61
+ }
62
+
63
+ test('a top-level handler appears unchanged as the listener argument', () => {
64
+ const handler = HANDLERS['conditional between arrows']
65
+ const js = compile(positions(handler)['top-level element'])
66
+ expect(js).toContain(`.addEventListener('click', ${handler})`)
67
+ })
68
+
69
+ test('a comma sequence stays one listener argument', () => {
70
+ const js = compile(positions(HANDLERS['comma sequence'])['top-level element'])
71
+ expect(js).toContain(`.addEventListener('click', (setN(1), () => setN(n() + 1)))`)
72
+ })
73
+ })
@@ -1,6 +1,6 @@
1
1
  import { describe, test, expect } from 'bun:test'
2
2
  import ts from 'typescript'
3
- import { parseExpression, isSupported, isSupportedValue, exprToString, stringifyParsedExpr, parseBlockBody, foldBlockToExpr, extractArrowBodyExpression, parseStyleObjectEntries, parseProviderObjectLiteral, asCallbackMethodCall, containsHigherOrder } from '../expression-parser'
3
+ import { parseExpression, isSupported, isSupportedValue, exprToString, stringifyParsedExpr, parseBlockBody, foldBlockToExpr, extractArrowBodyExpression, parseProviderObjectLiteral, asCallbackMethodCall, containsHigherOrder } from '../expression-parser'
4
4
  import { collectAllTypeRanges, reconstructWithoutTypes } from '../strip-types'
5
5
 
6
6
  describe('expression-parser', () => {
@@ -2036,49 +2036,6 @@ describe('parseProviderObjectLiteral', () => {
2036
2036
  })
2037
2037
  })
2038
2038
 
2039
- describe('parseStyleObjectEntries', () => {
2040
- test('kebab-cases keys and splits literal vs expression values', () => {
2041
- expect(parseStyleObjectEntries("{ backgroundColor: color, padding: '8px' }")).toEqual([
2042
- { cssKey: 'background-color', kind: 'expr', expr: 'color' },
2043
- { cssKey: 'padding', kind: 'literal', value: '8px' },
2044
- ])
2045
- })
2046
-
2047
- test('handles signal-getter call values as expressions', () => {
2048
- expect(parseStyleObjectEntries('{ background: bg(), color: fg() }')).toEqual([
2049
- { cssKey: 'background', kind: 'expr', expr: 'bg()' },
2050
- { cssKey: 'color', kind: 'expr', expr: 'fg()' },
2051
- ])
2052
- })
2053
-
2054
- test('quoted keys are honoured', () => {
2055
- expect(parseStyleObjectEntries("{ 'z-index': '1' }")).toEqual([
2056
- { cssKey: 'z-index', kind: 'literal', value: '1' },
2057
- ])
2058
- })
2059
-
2060
- test('vendor-prefixed keys keep the leading dash', () => {
2061
- expect(parseStyleObjectEntries("{ WebkitTransform: 'none' }")).toEqual([
2062
- { cssKey: '-webkit-transform', kind: 'literal', value: 'none' },
2063
- ])
2064
- // The `ms` prefix is lowercase in React style keys but the CSS property
2065
- // carries a leading dash (`-ms-transform`), unlike `Webkit`/`Moz`.
2066
- expect(parseStyleObjectEntries("{ msTransform: 'none' }")).toEqual([
2067
- { cssKey: '-ms-transform', kind: 'literal', value: 'none' },
2068
- ])
2069
- })
2070
-
2071
- test('returns null for unsupported shapes (spread / shorthand / computed)', () => {
2072
- expect(parseStyleObjectEntries('{ ...rest }')).toBeNull()
2073
- expect(parseStyleObjectEntries('{ color }')).toBeNull()
2074
- expect(parseStyleObjectEntries('{ [k]: v }')).toBeNull()
2075
- })
2076
-
2077
- test('returns null for a non-object source', () => {
2078
- expect(parseStyleObjectEntries('color')).toBeNull()
2079
- })
2080
- })
2081
-
2082
2039
  // =============================================================================
2083
2040
  // Block → Expression Normalization (#2040)
2084
2041
  // =============================================================================
@@ -3,7 +3,9 @@ import { analyzeComponent } from '../analyzer'
3
3
  import { parseExpression } from '../expression-parser'
4
4
  import {
5
5
  arithmeticOperandCoercion,
6
+ arithmeticOperandIsUndefined,
6
7
  attrValueMayBeNullish,
8
+ collectAbsentPropSeedReads,
7
9
  collectNullableSignalGetters,
8
10
  collectNullishAttrContext,
9
11
  nullableSignalAttrGetter,
@@ -50,6 +52,47 @@ describe('collectNullableSignalGetters (#3304)', () => {
50
52
  })
51
53
  })
52
54
 
55
+ function componentIR(params: string, decls: string): ComponentIR {
56
+ const source = `
57
+ 'use client'
58
+ import { createSignal } from '@barefootjs/client'
59
+ export function C(${params}) {
60
+ ${decls}
61
+ return <p>x</p>
62
+ }
63
+ `
64
+ return { metadata: analyzeComponent(source, 'C.tsx') } as unknown as ComponentIR
65
+ }
66
+
67
+ describe('signals seeded from an absent optional prop (#3567)', () => {
68
+ test('a bare read, a ternary branch and a `??` right operand are nullable', () => {
69
+ const ir = componentIR('props: { a?: string; b?: string; c?: string }', `
70
+ const [bare] = createSignal(props.a)
71
+ const [branch] = createSignal(props.a === 'x' ? props.b : 'y')
72
+ const [fallback] = createSignal(props.a ?? props.c)
73
+ `)
74
+ expect([...collectNullableSignalGetters(ir)].sort()).toEqual(['bare', 'branch', 'fallback'])
75
+ expect(collectAbsentPropSeedReads(ir).get('branch')).toEqual(new Set(['b']))
76
+ expect(collectAbsentPropSeedReads(ir).get('fallback')).toEqual(new Set(['c']))
77
+ })
78
+
79
+ test('destructured params are read by their binding name', () => {
80
+ const ir = componentIR('{ label }: { label?: string }', 'const [shown] = createSignal(label)')
81
+ expect([...collectNullableSignalGetters(ir)]).toEqual(['shown'])
82
+ })
83
+
84
+ test('a required prop, a defaulted prop, a `??` left operand or a value built from the prop is not', () => {
85
+ const ir = componentIR("{ req, def = 'd', opt }: { req: string; def?: string; opt?: string }", `
86
+ const [a] = createSignal(req)
87
+ const [b] = createSignal(def)
88
+ const [c] = createSignal(opt ?? 'x')
89
+ const [d] = createSignal(opt === 'x')
90
+ const [e] = createSignal(\`\${opt}\`)
91
+ `)
92
+ expect([...collectNullableSignalGetters(ir)]).toEqual([])
93
+ })
94
+ })
95
+
53
96
  describe('nullableSignalAttrGetter (#3304)', () => {
54
97
  const nullable = new Set(['s'])
55
98
 
@@ -141,14 +184,35 @@ describe('arithmeticOperandCoercion (#3474)', () => {
141
184
  arithmeticOperandCoercion(op, parseExpression(operand), parseExpression(other), ctx)
142
185
 
143
186
  test('a nullable number prop reads as null under every arithmetic operator, + with a number included', () => {
144
- const ctx = ctxOf('props: { a: number | null; b?: number; c: number; d: string | null }')
187
+ const ctx = ctxOf('props: { a: number | null; c: number; d: string | null }')
145
188
  for (const op of ['-', '*', '/', '%', '**']) expect(coercion(ctx, op, 'props.a', 'x')).toBe('null')
146
189
  expect(coercion(ctx, '+', 'props.a', '1')).toBe('null')
147
- expect(coercion(ctx, '+', 'props.b', '-2')).toBe('null')
148
190
  expect(coercion(ctx, '*', 'props.c', '2')).toBeNull()
149
191
  expect(coercion(ctx, '*', 'props.d', '2')).toBeNull()
150
192
  })
151
193
 
194
+ test('a number prop that can only be absent reads its nil as undefined (#3533)', () => {
195
+ const ctx = ctxOf('props: { b?: number; u: number | undefined; both?: number | null }')
196
+ for (const op of ['-', '*', '/', '%', '**']) expect(coercion(ctx, op, 'props.b', 'x')).toBe('undefined')
197
+ expect(coercion(ctx, '+', 'props.b', '-2')).toBe('undefined')
198
+ expect(coercion(ctx, '*', 'props.u', '2')).toBe('undefined')
199
+ // A type that admits both keeps the null reading: its nil can be either.
200
+ expect(coercion(ctx, '*', 'props.both', '2')).toBe('null')
201
+ })
202
+
203
+ test('unary minus passes no other operand and coerces like binary minus (#3533)', () => {
204
+ const ctx = ctxOf('props: { a: number | null; b?: number; c: number }')
205
+ const unary = (operand: string) => arithmeticOperandCoercion('-', parseExpression(operand), undefined, ctx)
206
+ expect(unary('props.a')).toBe('null')
207
+ expect(unary('props.b')).toBe('undefined')
208
+ expect(unary('props.c')).toBeNull()
209
+ })
210
+
211
+ test('an absent-only prop is not certainly undefined: arithmeticOperandIsUndefined stays false', () => {
212
+ const ctx = ctxOf('props: { b?: number }')
213
+ expect(arithmeticOperandIsUndefined(parseExpression('props.b'), ctx)).toBe(false)
214
+ })
215
+
152
216
  test('+ is left alone unless the other operand is a number: it may concatenate', () => {
153
217
  const ctx = ctxOf('props: { a: number | null }', 'const [n] = createSignal<number | null>(null)')
154
218
  expect(coercion(ctx, '+', 'props.a', 'label')).toBeNull()
@@ -158,7 +222,7 @@ describe('arithmeticOperandCoercion (#3474)', () => {
158
222
 
159
223
  test('a destructured nullable number prop, and a shadowed one', () => {
160
224
  const ctx = ctxOf('{ a }: { a?: number }')
161
- expect(coercion(ctx, '*', 'a', '2')).toBe('null')
225
+ expect(coercion(ctx, '*', 'a', '2')).toBe('undefined')
162
226
  expect(arithmeticOperandCoercion('*', parseExpression('a'), parseExpression('2'), ctx, n => n === 'a')).toBeNull()
163
227
  })
164
228