@barefootjs/jsx 0.39.4 → 0.39.6
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.
- package/dist/adapters/array-method.d.ts +93 -0
- package/dist/adapters/array-method.d.ts.map +1 -0
- package/dist/adapters/attr-plan.d.ts +135 -0
- package/dist/adapters/attr-plan.d.ts.map +1 -0
- package/dist/adapters/boolean-result.d.ts +84 -9
- package/dist/adapters/boolean-result.d.ts.map +1 -1
- package/dist/adapters/callback-method.d.ts +126 -0
- package/dist/adapters/callback-method.d.ts.map +1 -0
- package/dist/adapters/component-props.d.ts +99 -0
- package/dist/adapters/component-props.d.ts.map +1 -0
- package/dist/adapters/component-tree.d.ts +25 -0
- package/dist/adapters/component-tree.d.ts.map +1 -0
- package/dist/adapters/filter-capture-collisions.d.ts +17 -0
- package/dist/adapters/filter-capture-collisions.d.ts.map +1 -0
- package/dist/adapters/literal-value.d.ts +22 -0
- package/dist/adapters/literal-value.d.ts.map +1 -0
- package/dist/adapters/loop-plan.d.ts +53 -0
- package/dist/adapters/loop-plan.d.ts.map +1 -0
- package/dist/adapters/parsed-expr-emitter.d.ts +8 -0
- package/dist/adapters/parsed-expr-emitter.d.ts.map +1 -1
- package/dist/adapters/prop-classes.d.ts +37 -0
- package/dist/adapters/prop-classes.d.ts.map +1 -0
- package/dist/adapters/template-name-collisions.d.ts +21 -0
- package/dist/adapters/template-name-collisions.d.ts.map +1 -0
- package/dist/analyzer-context.d.ts.map +1 -1
- package/dist/expression-parser.d.ts +48 -0
- package/dist/expression-parser.d.ts.map +1 -1
- package/dist/index.d.ts +20 -4
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +2077 -1000
- package/dist/ir-to-client-js/collect-elements.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/plan/build-inner-loop.d.ts +8 -0
- package/dist/ir-to-client-js/control-flow/plan/build-inner-loop.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/plan/build-loop-child-arm.d.ts +3 -2
- package/dist/ir-to-client-js/control-flow/plan/build-loop-child-arm.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/shared.d.ts.map +1 -1
- package/dist/ir-to-client-js/html-template.d.ts.map +1 -1
- package/dist/ir-to-client-js/utils.d.ts +39 -1
- package/dist/ir-to-client-js/utils.d.ts.map +1 -1
- package/dist/jsx-to-ir.d.ts +465 -1
- package/dist/jsx-to-ir.d.ts.map +1 -1
- package/dist/nullable-signal-attr.d.ts +31 -0
- package/dist/nullable-signal-attr.d.ts.map +1 -1
- package/dist/scope/binding-scope.d.ts +10 -0
- package/dist/scope/binding-scope.d.ts.map +1 -1
- package/dist/types.d.ts +7 -0
- package/dist/types.d.ts.map +1 -1
- package/package.json +2 -2
- package/src/__tests__/__snapshots__/doc-examples.test.ts.snap +1 -1
- package/src/__tests__/action-accessor.test.ts +6 -24
- package/src/__tests__/array-method-catalogue.test.ts +99 -0
- package/src/__tests__/attr-plan.test.ts +121 -0
- package/src/__tests__/binding-scope-ratchet.test.ts +13 -13
- package/src/__tests__/binding-scope.test.ts +11 -0
- package/src/__tests__/boolean-result-expr.test.ts +106 -0
- package/src/__tests__/boolean-result.test.ts +34 -1
- package/src/__tests__/callback-method.test.ts +189 -0
- package/src/__tests__/compile-without-node-process.test.ts +78 -0
- package/src/__tests__/component-props.test.ts +148 -0
- package/src/__tests__/delegated-handler-preamble.test.ts +4 -4
- package/src/__tests__/doc-examples.test.ts +1 -0
- package/src/__tests__/dsl-shared-helpers.test.ts +166 -0
- package/src/__tests__/issue-3240-nested-static-map-event-delegation.test.ts +1 -1
- package/src/__tests__/loop-plan.test.ts +104 -0
- package/src/__tests__/map-call-decisions.test.ts +521 -0
- package/src/__tests__/nested-row-shadowing.test.ts +57 -0
- package/src/__tests__/nullable-signal-attr.test.ts +45 -0
- package/src/__tests__/rename-free-identifiers.test.ts +26 -0
- package/src/__tests__/template-name-collisions.test.ts +81 -0
- package/src/adapters/array-method.ts +193 -0
- package/src/adapters/attr-plan.ts +200 -0
- package/src/adapters/boolean-result.ts +208 -12
- package/src/adapters/callback-method.ts +301 -0
- package/src/adapters/component-props.ts +144 -0
- package/src/adapters/component-tree.ts +118 -0
- package/src/adapters/filter-capture-collisions.ts +29 -0
- package/src/adapters/literal-value.ts +36 -0
- package/src/adapters/loop-plan.ts +88 -0
- package/src/adapters/parsed-expr-emitter.ts +18 -0
- package/src/adapters/prop-classes.ts +73 -0
- package/src/adapters/template-name-collisions.ts +120 -0
- package/src/analyzer-context.ts +15 -1
- package/src/expression-parser.ts +569 -374
- package/src/index.ts +58 -3
- package/src/ir-to-client-js/collect-elements.ts +11 -7
- package/src/ir-to-client-js/control-flow/plan/build-inner-loop.ts +31 -10
- package/src/ir-to-client-js/control-flow/plan/build-loop-child-arm.ts +12 -5
- package/src/ir-to-client-js/control-flow/plan/build-reactive-effects.ts +2 -2
- package/src/ir-to-client-js/control-flow/shared.ts +4 -1
- package/src/ir-to-client-js/control-flow/stringify/event-delegation.ts +9 -7
- package/src/ir-to-client-js/html-template.ts +13 -7
- package/src/ir-to-client-js/index.ts +7 -2
- package/src/ir-to-client-js/utils.ts +81 -7
- package/src/jsx-to-ir.ts +1328 -991
- package/src/nullable-signal-attr.ts +116 -6
- package/src/scope/binding-scope.ts +19 -0
- package/src/types.ts +7 -0
package/dist/jsx-to-ir.d.ts
CHANGED
|
@@ -3,7 +3,471 @@
|
|
|
3
3
|
*
|
|
4
4
|
* Transforms TypeScript JSX AST to Pure IR (JSX-independent JSON structure).
|
|
5
5
|
*/
|
|
6
|
-
import
|
|
6
|
+
import ts from 'typescript';
|
|
7
|
+
import { type IRNode, type LoopParamBinding, type FlatMapCallback, type MapCallbackPreamble, type PreambleRegionSource } from './types.ts';
|
|
7
8
|
import { type AnalyzerContext } from './analyzer-context.ts';
|
|
9
|
+
import { type ParsedExpr } from './expression-parser.ts';
|
|
10
|
+
import type { IRLoopSort, ConstantInfo, ParamInfo } from './types.ts';
|
|
11
|
+
import { type ClientBuiltinTag } from './builtins.ts';
|
|
12
|
+
import { type BindingEnvironment } from './free-refs.ts';
|
|
13
|
+
import type { LoweringMatcher } from './lowering-registry.ts';
|
|
14
|
+
import { BindingScope } from './scope/binding-scope.ts';
|
|
15
|
+
/** Pre-compiled regex patterns for reactivity detection */
|
|
16
|
+
interface ReactivityPatterns {
|
|
17
|
+
signals: {
|
|
18
|
+
getter: string;
|
|
19
|
+
pattern: RegExp;
|
|
20
|
+
}[];
|
|
21
|
+
memos: {
|
|
22
|
+
name: string;
|
|
23
|
+
pattern: RegExp;
|
|
24
|
+
}[];
|
|
25
|
+
/** For regex `props.<key>` detection only — for exact-name binding checks read `TransformContext.boundPropNames` instead (#2835). */
|
|
26
|
+
props: {
|
|
27
|
+
name: string;
|
|
28
|
+
pattern: RegExp;
|
|
29
|
+
}[];
|
|
30
|
+
constants: {
|
|
31
|
+
name: string;
|
|
32
|
+
value: string | undefined;
|
|
33
|
+
pattern: RegExp;
|
|
34
|
+
}[];
|
|
35
|
+
}
|
|
36
|
+
/** @internal exported for the per-decision loop tests (`map-call-decisions.test.ts`). */
|
|
37
|
+
export interface TransformContext {
|
|
38
|
+
analyzer: AnalyzerContext;
|
|
39
|
+
sourceFile: ts.SourceFile;
|
|
40
|
+
filePath: string;
|
|
41
|
+
slotIdCounter: number;
|
|
42
|
+
isRoot: boolean;
|
|
43
|
+
insideComponentChildren: boolean;
|
|
44
|
+
patterns: ReactivityPatterns;
|
|
45
|
+
/**
|
|
46
|
+
* Local names actually bound by the props parameter (#2835) — unlike
|
|
47
|
+
* `patterns.props`, which for a whole `(props: Props)` parameter holds
|
|
48
|
+
* every TYPE-MEMBER name (needed so its regex `pattern` still matches
|
|
49
|
+
* `props.<key>` accesses), this is empty in that shape since none of
|
|
50
|
+
* those names are local bindings a shadow check could ever see.
|
|
51
|
+
*/
|
|
52
|
+
boundPropNames: ReadonlySet<string>;
|
|
53
|
+
/** Shortcut for analyzer.getJS(node) */
|
|
54
|
+
getJS(node: ts.Node): string;
|
|
55
|
+
/** getJS + rewrite destructured prop refs for client JS templates (#807) */
|
|
56
|
+
getTemplateJS(node: ts.Node): string;
|
|
57
|
+
/** Cached set of reactive getter names (signal getters + memo names) for O(1) lookup */
|
|
58
|
+
_reactiveGetterNames?: Set<string>;
|
|
59
|
+
/** Cached set of module-scope @client signal/memo names. */
|
|
60
|
+
_moduleClientSignalNames?: Set<string>;
|
|
61
|
+
/**
|
|
62
|
+
* Cached `localConstants` index (name → value text), shared by every
|
|
63
|
+
* `resolveAliasOrigin` walk in this file — `forwardsCallerRestProps`'s
|
|
64
|
+
* rest/props-spread alias walk and `isArrayExprDirectPropRef`'s
|
|
65
|
+
* direct-prop-array alias walk (#2724).
|
|
66
|
+
*/
|
|
67
|
+
_constantValuesByName?: ReadonlyMap<string, string | undefined>;
|
|
68
|
+
/**
|
|
69
|
+
* Cached `localConstants` index (name → full `ConstantInfo`), for
|
|
70
|
+
* lookups that need more than the value text — e.g.
|
|
71
|
+
* `isArrayExprDirectPropRef` reading a constant's structured `.parsed`
|
|
72
|
+
* to recognize `const arr = props.items` (#2724).
|
|
73
|
+
*/
|
|
74
|
+
_constantsByName?: ReadonlyMap<string, ConstantInfo>;
|
|
75
|
+
/** Cached set of destructured prop names for AST-based rewriting */
|
|
76
|
+
_destructuredPropNames?: Set<string> | null;
|
|
77
|
+
/**
|
|
78
|
+
* Cached local-name → caller-facing-key (`sourceName ?? name`) map for
|
|
79
|
+
* `_destructuredPropNames`, entries only for names that actually rename
|
|
80
|
+
* (`{ n: count }` → `count` → `n`). Built alongside `_destructuredPropNames`
|
|
81
|
+
* so both stay in lockstep with the same shadow-filtered eligible set —
|
|
82
|
+
* consumed by `rewriteBarePropRefsCore` to emit `_p.<caller>` instead of
|
|
83
|
+
* `_p.<local>` (#2524 CSR half: `_p` is always caller-keyed).
|
|
84
|
+
*/
|
|
85
|
+
_destructuredPropAliases?: Map<string, string> | null;
|
|
86
|
+
/**
|
|
87
|
+
* Cached local-name → `ParamInfo` map for the same eligible set, so
|
|
88
|
+
* `rewriteBarePropRefs` can apply a prop's destructure DEFAULT. Without
|
|
89
|
+
* it the CSR-only `template:` literal emitted a bare `_p.label` for
|
|
90
|
+
* `data-label={label}` with `label = 'none'`: correct once the caller
|
|
91
|
+
* sends a value, but the attribute was omitted entirely on the first
|
|
92
|
+
* render, where `_p.label` is `undefined`. Covers PARAMETER destructuring
|
|
93
|
+
* and an UNRENAMED BODY destructure default alike (`function Foo(props) {
|
|
94
|
+
* const { label = 'none' } = props }`) — both populate `defaultValue`
|
|
95
|
+
* directly on `propsParams` (the parameter form in `extractProps`, the
|
|
96
|
+
* body form via `collectConstant`'s overlay, #2943), so this map is a
|
|
97
|
+
* plain re-keying of `eligible`, no second default-resolution needed.
|
|
98
|
+
*/
|
|
99
|
+
_destructuredPropInfoByName?: ReadonlyMap<string, ParamInfo> | null;
|
|
100
|
+
/**
|
|
101
|
+
* The active `.map()`/callback binding stack (#2482 Stage 1a) — replaces
|
|
102
|
+
* the former mutable per-name `Set<string>` mutated in lockstep with
|
|
103
|
+
* `transformMapCall` entry/exit. `enterLoopRow`/`enterCallback` return a
|
|
104
|
+
* NEW `BindingScope`; restoring the saved parent reference on exit is
|
|
105
|
+
* the whole mechanism (no `.delete()` bookkeeping to get wrong).
|
|
106
|
+
*/
|
|
107
|
+
scope: BindingScope;
|
|
108
|
+
/**
|
|
109
|
+
* Count of enclosing `.map()` loops (0 = outermost), incremented/
|
|
110
|
+
* decremented in lockstep with entering/leaving `transformMapCall`.
|
|
111
|
+
* Unlike `scope` (a binding stack that can gain several bound names for
|
|
112
|
+
* ONE loop level via destructuring), this is a plain per-level
|
|
113
|
+
* counter — the single source of truth `IRLoop.depth` is stamped
|
|
114
|
+
* from, so every adapter's `data-key`/`data-key-N` suffix derives
|
|
115
|
+
* from one IR-computed value instead of each adapter re-deriving
|
|
116
|
+
* nesting depth its own way (#2168 nested-loop-outer-binding).
|
|
117
|
+
*/
|
|
118
|
+
loopDepth: number;
|
|
119
|
+
/** Counter for async boundary IDs (a0, a1, ...) */
|
|
120
|
+
asyncIdCounter: number;
|
|
121
|
+
/** Counter for <Region> structural index (0, 1, ...) within a file. */
|
|
122
|
+
regionIdCounter: number;
|
|
123
|
+
/** Counter for loop marker IDs (l0, l1, ...) — separate from slot IDs so element bf="sN" numbering stays stable across versions (#1087). */
|
|
124
|
+
loopMarkerCounter: number;
|
|
125
|
+
/**
|
|
126
|
+
* Counter for JSX spread bag slot IDs (`Spread_0`, `Spread_1`, ...).
|
|
127
|
+
* Separate namespace from element slot IDs (`s0`, `s1`, ...) so
|
|
128
|
+
* adapters that need to plumb the spread bag through a structured
|
|
129
|
+
* data path (Go template's `.Spread_N`) don't collide with element
|
|
130
|
+
* scope IDs (#1407). Component-scoped, allocated only when the
|
|
131
|
+
* spread falls through to the bag-emitting branch.
|
|
132
|
+
*/
|
|
133
|
+
spreadIdCounter: number;
|
|
134
|
+
/**
|
|
135
|
+
* Memoized free-refs binding environment. Built lazily by
|
|
136
|
+
* `makeBindingEnv` and reused across every `resolveFreeRefs` call as
|
|
137
|
+
* long as `scope`'s bound VALUE names are unchanged. Invalidated by
|
|
138
|
+
* serializing `scope.valueBoundNames()` into `_bindingEnvLoopKey` and
|
|
139
|
+
* comparing on read.
|
|
140
|
+
*/
|
|
141
|
+
_bindingEnv?: BindingEnvironment;
|
|
142
|
+
_bindingEnvLoopKey?: string;
|
|
143
|
+
/**
|
|
144
|
+
* Lazily computed map of `Pkg.Comp` → `Comp` resolutions for
|
|
145
|
+
* member-expression JSX tags (#1319). A `const Pkg = { Comp }` (or
|
|
146
|
+
* `{ Comp: ComponentName }`) in module scope lets the CSR template
|
|
147
|
+
* emit `renderChild('Comp', ...)` instead of the literal
|
|
148
|
+
* `renderChild('Pkg.Comp', ...)` which fails the registry lookup.
|
|
149
|
+
*/
|
|
150
|
+
_componentNamespaces?: Map<string, Map<string, string>>;
|
|
151
|
+
/**
|
|
152
|
+
* Per-branch overlay of `const X = expr` declared inside an early-
|
|
153
|
+
* return `if`-block, populated by `buildIfStatementChain` before
|
|
154
|
+
* transforming the consequent JSX (#1409). When a JSX expression
|
|
155
|
+
* references one of these names, `transformExpression` inlines the
|
|
156
|
+
* initializer at the use site — the same way module-scope JSX
|
|
157
|
+
* constants are inlined via `analyzer.jsxConstants` (#547) — instead
|
|
158
|
+
* of leaving the identifier to leak into the emitted client JS at
|
|
159
|
+
* outer init scope where the binding doesn't exist. Saved/restored
|
|
160
|
+
* around each `transformNode(condReturn.jsxReturn, ctx)` call so
|
|
161
|
+
* sibling branches do not see each other's locals.
|
|
162
|
+
*/
|
|
163
|
+
_branchScopeVars?: Map<string, ts.Expression>;
|
|
164
|
+
/**
|
|
165
|
+
* Subset of `_branchScopeVars` names whose initializer carries JSX
|
|
166
|
+
* (so text substitution into raw-captured callback bodies is unsafe
|
|
167
|
+
* — TS JSX in JS syntax is invalid). `processAttributes` consults
|
|
168
|
+
* this set when extracting ref / event-handler bodies and emits
|
|
169
|
+
* BF047 if any of these names appears as a free identifier in the
|
|
170
|
+
* callback body. See #1414 cell 5.
|
|
171
|
+
*/
|
|
172
|
+
_jsxBranchLocalNames?: Set<string>;
|
|
173
|
+
/**
|
|
174
|
+
* Set of destructured prop names each branch-local transitively
|
|
175
|
+
* references in its initializer (directly or via inner-branch-local
|
|
176
|
+
* substitution). Populated alongside `_branchScopeVars`; consumed
|
|
177
|
+
* by `rewriteBarePropRefs` so prop refs introduced via text-level
|
|
178
|
+
* branch-local substitution still get bridged to `_p.X` in CSR
|
|
179
|
+
* template scope even though the use-site AST doesn't carry them.
|
|
180
|
+
* See #1425.
|
|
181
|
+
*/
|
|
182
|
+
_branchScopePropDeps?: Map<string, Set<string>>;
|
|
183
|
+
/**
|
|
184
|
+
* Lazily computed map of local JSX tag name → compile-away built-in
|
|
185
|
+
* (`Async` / `Region`), derived from `@barefootjs/client` imports (#1915).
|
|
186
|
+
* Recognition is import-scoped (not a bare tag-name match) so a user's own
|
|
187
|
+
* `<Async>` / `<Region>` component doesn't collide with the built-in, and an
|
|
188
|
+
* aliased `import { Async as Boundary }` maps `<Boundary>` to the built-in.
|
|
189
|
+
*/
|
|
190
|
+
_clientBuiltinTags?: Map<string, ClientBuiltinTag>;
|
|
191
|
+
/** Lazily computed local name → export name of every `@barefootjs/client` value import. */
|
|
192
|
+
_clientValueImports?: ReadonlyMap<string, string>;
|
|
193
|
+
/**
|
|
194
|
+
* BF063 candidates keyed by element position (`line:column`), recorded
|
|
195
|
+
* while transforming and reported by `reportRefAttrsAbsentAtSsr` once the
|
|
196
|
+
* IR shows which elements SSR renders.
|
|
197
|
+
*/
|
|
198
|
+
_refAttrAbsences?: Map<string, RefAttrAbsence>;
|
|
199
|
+
/**
|
|
200
|
+
* Cached `datePlugin` matcher (#2292), bound once to this component's
|
|
201
|
+
* metadata. `undefined` = not yet computed; `null` = computed and
|
|
202
|
+
* inactive (this component's props never reach a `Date`, `datePlugin`'s
|
|
203
|
+
* own `prepare` gate). See `getDateLoweringMatcher`.
|
|
204
|
+
*/
|
|
205
|
+
_dateLoweringMatcher?: LoweringMatcher | null;
|
|
206
|
+
/**
|
|
207
|
+
* Cached `toLocaleDatePlugin` matcher (#2324 slice 2), same lifecycle as
|
|
208
|
+
* `_dateLoweringMatcher`. See `getToLocaleDateLoweringMatcher`.
|
|
209
|
+
*/
|
|
210
|
+
_toLocaleDateLoweringMatcher?: LoweringMatcher | null;
|
|
211
|
+
}
|
|
212
|
+
/** @internal exported for the per-decision loop tests (`map-call-decisions.test.ts`). */
|
|
213
|
+
export declare function createTransformContext(analyzer: AnalyzerContext): TransformContext;
|
|
8
214
|
export declare function jsxToIR(analyzer: AnalyzerContext): IRNode | null;
|
|
215
|
+
/**
|
|
216
|
+
* Result type for extractFilterPredicate. The predicate is always an expression:
|
|
217
|
+
* a block body is normalized to one via `foldBlockToExpr` +
|
|
218
|
+
* `predicateTernaryToLogical` (#2040).
|
|
219
|
+
*/
|
|
220
|
+
type FilterPredicateResult = {
|
|
221
|
+
param: string;
|
|
222
|
+
predicate?: ParsedExpr;
|
|
223
|
+
raw: string;
|
|
224
|
+
};
|
|
225
|
+
/**
|
|
226
|
+
* The loop's SOURCE after the receiver chain is recognised: the array
|
|
227
|
+
* expression the loop iterates (`array`, its `_p.`-rewritten `templateArray`
|
|
228
|
+
* twin, and the AST node it was read from), plus whatever the chain lifted
|
|
229
|
+
* out of it — the filter predicate, the sort comparator, their order, and
|
|
230
|
+
* the `.entries()` / `Object.entries()` iteration shape.
|
|
231
|
+
*/
|
|
232
|
+
export interface LoopSourcePlan {
|
|
233
|
+
array: string;
|
|
234
|
+
templateArray: string | undefined;
|
|
235
|
+
/**
|
|
236
|
+
* AST node `array` was read from, so the static-array decision can run
|
|
237
|
+
* `exprHasFunctionCalls` on it. Starts as the full map source, which
|
|
238
|
+
* matches the plain-`.map()` fallback.
|
|
239
|
+
*/
|
|
240
|
+
arrayExpr: ts.Expression;
|
|
241
|
+
filterPredicate: FilterPredicateResult | undefined;
|
|
242
|
+
sortComparator: IRLoopSort | undefined;
|
|
243
|
+
chainOrder: 'filter-sort' | 'sort-filter' | undefined;
|
|
244
|
+
iterationShape: 'entries' | 'keys' | undefined;
|
|
245
|
+
objectIteration: 'entries' | 'keys' | 'values' | undefined;
|
|
246
|
+
}
|
|
247
|
+
/**
|
|
248
|
+
* Decision 1 — recognise the receiver of `.map()` and decide what the loop
|
|
249
|
+
* iterates. Chaining patterns on the map source:
|
|
250
|
+
*
|
|
251
|
+
* 1. `sort().map()` / `toSorted().map()`
|
|
252
|
+
* 2. `filter().map()`
|
|
253
|
+
* 3. `filter().sort().map()` (outermost = sort, inner = filter)
|
|
254
|
+
* 4. `sort().filter().map()` (outermost = filter, inner = sort)
|
|
255
|
+
* 5. `entries().map()` / `keys().map()` / `values().map()`, and the static
|
|
256
|
+
* `Object.entries(x).map()` family
|
|
257
|
+
*
|
|
258
|
+
* Every branch binds the array through `setArray` so `templateArray`
|
|
259
|
+
* carries the `_p.`-rewritten form (#2222): the plain `.map()` fallback is
|
|
260
|
+
* the most common loop shape and was the primary repro for the
|
|
261
|
+
* bare-destructured-name ReferenceError.
|
|
262
|
+
*
|
|
263
|
+
* @internal exported for unit tests
|
|
264
|
+
*/
|
|
265
|
+
export declare function resolveLoopSource(node: ts.CallExpression, ctx: TransformContext, isClientOnly: boolean): LoopSourcePlan;
|
|
266
|
+
/** The names one loop row binds, read off the callback's parameter list. */
|
|
267
|
+
export interface LoopRowParams {
|
|
268
|
+
param: string;
|
|
269
|
+
paramType: string | undefined;
|
|
270
|
+
index: string | null;
|
|
271
|
+
indexType: string | undefined;
|
|
272
|
+
paramBindings: LoopParamBinding[] | undefined;
|
|
273
|
+
/** Node whose checker type is the scalar item-type evidence (`IRLoop.itemType`). */
|
|
274
|
+
itemTypeNode: ts.Node | undefined;
|
|
275
|
+
}
|
|
276
|
+
/**
|
|
277
|
+
* Decision 2 — the names a row binds: the item param (and its type text),
|
|
278
|
+
* the index param, and the destructure accessor paths. An `.entries()`
|
|
279
|
+
* shape takes its index from the 2-tuple destructure instead of a second
|
|
280
|
+
* parameter.
|
|
281
|
+
*
|
|
282
|
+
* @internal exported for unit tests
|
|
283
|
+
*/
|
|
284
|
+
export declare function resolveLoopRowParams(callback: ts.ArrowFunction, source: Pick<LoopSourcePlan, 'iterationShape' | 'objectIteration'>, ctx: TransformContext): LoopRowParams;
|
|
285
|
+
/** What one `.map()` callback body lowers to. */
|
|
286
|
+
export interface LoopBodyLowering {
|
|
287
|
+
children: IRNode[];
|
|
288
|
+
/**
|
|
289
|
+
* Structured pre-return statements of a block-body callback (Stage 3 root
|
|
290
|
+
* cure): JS text + compiled JSX leaves as segments, plus the raw TSX for
|
|
291
|
+
* JSX-runtime SSR and the declared names (D5 key guard, {out} join).
|
|
292
|
+
*/
|
|
293
|
+
preamble: MapCallbackPreamble | undefined;
|
|
294
|
+
flatMapCallback: FlatMapCallback | undefined;
|
|
295
|
+
}
|
|
296
|
+
/**
|
|
297
|
+
* Run `fn` under the row's `BindingScope` frame. Registers the loop-bound
|
|
298
|
+
* names so expressions referencing them get a slotId (#2482 Stage 1a): for
|
|
299
|
+
* destructured patterns the frame binds the individual binding names —
|
|
300
|
+
* `\b${param}\b` never matches a bare name like `cfg` when `param` is
|
|
301
|
+
* `[, cfg]`, which would otherwise leave reactive-expression detection
|
|
302
|
+
* silently broken for destructured callbacks. `fn` receives the pre-loop
|
|
303
|
+
* parent scope (the frame the preamble-shadow window re-enters from). The
|
|
304
|
+
* parent is restored by reference, not deleted-from, so a nested loop
|
|
305
|
+
* reusing a param name can never corrupt the outer scope — the BindingScope
|
|
306
|
+
* twin of the old "unregister loop params" delete block, which can never
|
|
307
|
+
* miss an entry the add-site added.
|
|
308
|
+
*
|
|
309
|
+
* @internal exported for unit tests
|
|
310
|
+
*/
|
|
311
|
+
export declare function withLoopRowScope<T>(ctx: TransformContext, row: Pick<LoopRowParams, 'param' | 'index' | 'paramBindings'>, fn: (savedScope: BindingScope) => T): T;
|
|
312
|
+
/**
|
|
313
|
+
* Decision 3 — lower the callback body into the row's children, preamble
|
|
314
|
+
* and flatMap carrier. The caller has already entered the row's
|
|
315
|
+
* `BindingScope` frame (`ctx.scope`, see `withLoopRowScope`) and bumped
|
|
316
|
+
* `ctx.loopDepth`; `savedScope` is the pre-loop parent the preamble-shadow
|
|
317
|
+
* window re-enters from.
|
|
318
|
+
*
|
|
319
|
+
* @internal exported for unit tests
|
|
320
|
+
*/
|
|
321
|
+
export declare function transformLoopCallbackBody(callback: ts.ArrowFunction, row: LoopRowParams, savedScope: BindingScope, ctx: TransformContext, isClientOnly: boolean, method: 'map' | 'flatMap'): LoopBodyLowering;
|
|
322
|
+
/**
|
|
323
|
+
* Decision 4 — the structural net (sound-or-loud, spec/callback-fidelity.md):
|
|
324
|
+
* a callback body that carries an INLINE JSX literal but produced no loop
|
|
325
|
+
* lowering must never fall through to the IRExpression scalar path —
|
|
326
|
+
* `ctx.getJS` strips types, not JSX, so the raw `<li …>` would splice
|
|
327
|
+
* verbatim into the emitted client bundle as a silent SyntaxError. Any
|
|
328
|
+
* recognizer gap for a JSX-bearing shape becomes a loud diagnostic here
|
|
329
|
+
* instead of a leak. (A JSX-helper CALL — `map(t => renderItem(t))` —
|
|
330
|
+
* carries no inline JSX literal and legitimately stays on the reactive-text
|
|
331
|
+
* path.)
|
|
332
|
+
*
|
|
333
|
+
* Entry-count gate: a more specific refusal already fired for THIS call
|
|
334
|
+
* (e.g. the flatMap leaf-wiring check) — don't stack the generic message on
|
|
335
|
+
* top of it. Comparing against the count captured at entry (not `=== 0`)
|
|
336
|
+
* keeps the net armed when an unrelated diagnostic was recorded earlier in
|
|
337
|
+
* the file — a warning elsewhere must never silence the leak guard for this
|
|
338
|
+
* callback.
|
|
339
|
+
*
|
|
340
|
+
* @internal exported for unit tests
|
|
341
|
+
*/
|
|
342
|
+
export declare function refuseUnloweredJsxCallback(node: ts.CallExpression, ctx: TransformContext, method: 'map' | 'flatMap', diagCountAtEntry: number): void;
|
|
343
|
+
/** The loop's keyFn source and whether the body is a whole-item conditional. */
|
|
344
|
+
export interface LoopKeyPlan {
|
|
345
|
+
key: string | null;
|
|
346
|
+
bodyIsItemConditional: boolean;
|
|
347
|
+
}
|
|
348
|
+
/**
|
|
349
|
+
* Decision 5 — the row key. Emits BF023 / BF024 if the loop root element
|
|
350
|
+
* lacks a valid key attribute, then looks for the loop's keyFn source on the
|
|
351
|
+
* first child. `extractLoopKey` handles direct elements, child components,
|
|
352
|
+
* and — crucially — ternary bodies (#1098): when every branch of an
|
|
353
|
+
* `IRConditional` declares the same `key={EXPR}`, that EXPR is lifted out to
|
|
354
|
+
* mapArray's keyFn so a shape change (e.g. `<polygon>` ↔ `<circle>`)
|
|
355
|
+
* replaces the DOM node instead of mutating attributes on the wrong tag.
|
|
356
|
+
* Whole-item conditional bodies (#1665): the loop item is a single
|
|
357
|
+
* conditional whose at-least-one branch renders nothing, so an item shows
|
|
358
|
+
* 0-or-1 element. The key lives inside the rendering branch, so it is
|
|
359
|
+
* hoisted from there; the flag routes the loop through anchored emission
|
|
360
|
+
* downstream.
|
|
361
|
+
*
|
|
362
|
+
* #2753: the row's key ATTRIBUTE (name + value) is resolved here, once, and
|
|
363
|
+
* stamped onto the element(s) that render it — `null` (unkeyed) means no
|
|
364
|
+
* `IRElement.keyAttr` at all, which is the correct final answer for every
|
|
365
|
+
* adapter and the client runtime alike, not a hint they still have to gate.
|
|
366
|
+
* See `IRElement.keyAttr` / `applyLoopKeyAttr`'s docstrings.
|
|
367
|
+
*
|
|
368
|
+
* @internal exported for unit tests
|
|
369
|
+
*/
|
|
370
|
+
export declare function resolveLoopKey(callback: ts.ArrowFunction, children: IRNode[], ctx: TransformContext, isNested: boolean, depth: number): LoopKeyPlan;
|
|
371
|
+
/**
|
|
372
|
+
* Decision 6a — the JSX-building preamble's element-array children.
|
|
373
|
+
*
|
|
374
|
+
* Stage 3 / D4 — flag element-array children ({out}) built by the preamble
|
|
375
|
+
* so Phase-2 string emission joins them instead of `String([])`-collapsing
|
|
376
|
+
* them. Scoped to builderNames (leaf accumulators), NOT all declared locals
|
|
377
|
+
* — a value-only `{label}` keeps its historical plain interpolation.
|
|
378
|
+
*
|
|
379
|
+
* Stage 3 root cure — a JSX-building preamble feeding a COMPONENT root is
|
|
380
|
+
* refused: the component loop's rows are createComponent-driven ('dom-ops'
|
|
381
|
+
* row construction), and a lowered HTML-string leaf passed as a prop would
|
|
382
|
+
* silently diverge from SSR, where the same prop is a real JSX element.
|
|
383
|
+
* Refused = not carried (the old "do NOT collect" principle): codegen still
|
|
384
|
+
* runs on an errored compile, and the dom-ops backstop invariant must stay
|
|
385
|
+
* a FUTURE-variant tripwire, not re-fire on shapes Phase 1 already refused
|
|
386
|
+
* loudly. Returns the preamble to carry (`undefined` once refused).
|
|
387
|
+
*
|
|
388
|
+
* @internal exported for unit tests
|
|
389
|
+
*/
|
|
390
|
+
export declare function applyPreambleBuilderPasses(node: ts.CallExpression, children: IRNode[], preamble: MapCallbackPreamble | undefined, ctx: TransformContext): MapCallbackPreamble | undefined;
|
|
391
|
+
/** How the loop's array renders: static (prop) or reconciled (signal/memo/call). */
|
|
392
|
+
export interface LoopArrayClassification {
|
|
393
|
+
callsReactive: boolean;
|
|
394
|
+
hasCalls: boolean;
|
|
395
|
+
isDirectPropArray: boolean;
|
|
396
|
+
isStaticArray: boolean;
|
|
397
|
+
}
|
|
398
|
+
/**
|
|
399
|
+
* Decision 7 — is the array static (prop) or dynamic (signal/memo)? Static
|
|
400
|
+
* arrays don't need mapArray/mapArrayAnchored — SSR elements are hydrated
|
|
401
|
+
* directly. Signal / memo arrays need mapArray for dynamic DOM updates.
|
|
402
|
+
*
|
|
403
|
+
* Solid-style wrap-by-default fallback (#943, follow-up to
|
|
404
|
+
* #937/#939/#940/#941/#942): if the array expression AST contains a function
|
|
405
|
+
* call but the analyzer can't recognise the callee as a signal / memo, we
|
|
406
|
+
* still force reconciliation. `getItems().map(...)` where `getItems` is an
|
|
407
|
+
* imported helper previously silent-dropped into the static-render path,
|
|
408
|
+
* freezing the SSR-time list on the client. Over-reconciling an array that
|
|
409
|
+
* happens to contain a pure call costs one extra `mapArray` per loop;
|
|
410
|
+
* under-reconciling is the silent-drop bug this closes.
|
|
411
|
+
*
|
|
412
|
+
* Destructured map params (`([, cfg]) => ...`, `({ a, b }) => ...`, typed
|
|
413
|
+
* forms) used to be excluded from the widening to avoid a latent crash in
|
|
414
|
+
* the `mapArray` renderItem emitter — see #949 and the emitter-side
|
|
415
|
+
* `destructureLoopParam` helper, which now unwraps the signal accessor at
|
|
416
|
+
* renderItem body entry. No more skip.
|
|
417
|
+
*
|
|
418
|
+
* `objectIteration` (#2168 object-entries-map): `array` here is the STRIPPED
|
|
419
|
+
* object expression (`Object.entries(x)`'s `x`), which can itself be a
|
|
420
|
+
* static module-scope const object literal and would otherwise satisfy
|
|
421
|
+
* every check — but a plain OBJECT has no `.forEach()`/`.map()` (the
|
|
422
|
+
* static-array client codegen's own methods), unlike an actual array
|
|
423
|
+
* literal. Force the dynamic `mapArray()` path instead, which this shape's
|
|
424
|
+
* client-JS array-expr reconstruction (`applyObjectIterationWrap`,
|
|
425
|
+
* `ir-to-client-js/utils.ts`) already handles correctly.
|
|
426
|
+
*
|
|
427
|
+
* @internal exported for unit tests
|
|
428
|
+
*/
|
|
429
|
+
export declare function classifyLoopArray(source: Pick<LoopSourcePlan, 'array' | 'arrayExpr' | 'objectIteration'>, method: 'map' | 'flatMap', ctx: TransformContext): LoopArrayClassification;
|
|
430
|
+
/**
|
|
431
|
+
* Decision 6b — the preamble's after-the-fact reactivity wiring on a
|
|
432
|
+
* signal-backed (non-static) loop. Static arrays are never recreated via
|
|
433
|
+
* signals, so there is nothing to patch; they are skipped entirely.
|
|
434
|
+
*
|
|
435
|
+
* #2389 patch-on-update — a loop body with a preamble may reference a
|
|
436
|
+
* preamble-declared local directly as a child expression (`{cells}`,
|
|
437
|
+
* `{stateLabel}`). `mapArray` reuses the same DOM node on a same-key update,
|
|
438
|
+
* re-running only the wired text/attr slots — this child has neither, so
|
|
439
|
+
* without a dedicated region-patch effect it freezes at its mount-time
|
|
440
|
+
* value.
|
|
441
|
+
*
|
|
442
|
+
* #2447 follow-up — the ATTRIBUTE twin of the regions. `class={cls}` where
|
|
443
|
+
* the preamble declares `cls` froze at its row-construction value for the
|
|
444
|
+
* same reason `{cells}` did, and for one extra reason on top: an attribute
|
|
445
|
+
* only gets wired at all if its element carries a slot id, and
|
|
446
|
+
* `hasReactiveAttributes` (which decides that at element-build time, before
|
|
447
|
+
* any loop preamble is known) scores a bare local as non-reactive. So the
|
|
448
|
+
* slot has to be granted HERE, in the same after-the-fact pass the regions
|
|
449
|
+
* use — after which `collectLoopChildReactiveAttrs` classifies the attr and
|
|
450
|
+
* the row effect re-runs the preamble ahead of the write.
|
|
451
|
+
*
|
|
452
|
+
* #2596 — the CONDITION-position twin. See
|
|
453
|
+
* `markPreambleConditionalReactivity`'s docstring for why that one is gated
|
|
454
|
+
* on `reactiveNames` (genuinely signal-derived) rather than the blanket
|
|
455
|
+
* `declaredNames` the region/attr passes use.
|
|
456
|
+
*
|
|
457
|
+
* @internal exported for unit tests
|
|
458
|
+
*/
|
|
459
|
+
export declare function markPreambleReactivity(children: IRNode[], preamble: MapCallbackPreamble | undefined, isStaticArray: boolean, ctx: TransformContext): PreambleRegionSource[] | undefined;
|
|
460
|
+
/** A BF063 candidate awaiting `reportRefAttrsAbsentAtSsr`. */
|
|
461
|
+
interface RefAttrAbsence {
|
|
462
|
+
/** `<tag> at line:column`, naming the element in the diagnostic. */
|
|
463
|
+
element: string;
|
|
464
|
+
/** Mount-time writes of attributes this element's JSX never renders. */
|
|
465
|
+
writes: RefAttrWrite[];
|
|
466
|
+
}
|
|
467
|
+
interface RefAttrWrite {
|
|
468
|
+
/** Lower-cased HTML attribute name (`data-*` for a `dataset` write). */
|
|
469
|
+
name: string;
|
|
470
|
+
node: ts.Node;
|
|
471
|
+
}
|
|
472
|
+
export {};
|
|
9
473
|
//# sourceMappingURL=jsx-to-ir.d.ts.map
|
package/dist/jsx-to-ir.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"jsx-to-ir.d.ts","sourceRoot":"","sources":["../src/jsx-to-ir.ts"],"names":[],"mappings":"AAAA;;;;GAIG;
|
|
1
|
+
{"version":3,"file":"jsx-to-ir.d.ts","sourceRoot":"","sources":["../src/jsx-to-ir.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EACL,KAAK,MAAM,EAiBX,KAAK,gBAAgB,EAGrB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAExB,KAAK,oBAAoB,EAS1B,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,eAAe,EAA4F,MAAM,uBAAuB,CAAA;AACtJ,OAAO,EAAoP,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAC1S,OAAO,KAAK,EAAE,UAAU,EAAgB,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAGnF,OAAO,EAA8C,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAUjG,OAAO,EAAoD,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAM1G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAM7D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AASvD,2DAA2D;AAC3D,UAAU,kBAAkB;IAC1B,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC9C,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC1C,qIAAqI;IACrI,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC1C,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC1E;AAED,yFAAyF;AACzF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,eAAe,CAAA;IACzB,UAAU,EAAE,EAAE,CAAC,UAAU,CAAA;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,OAAO,CAAA;IACf,uBAAuB,EAAE,OAAO,CAAA;IAChC,QAAQ,EAAE,kBAAkB,CAAA;IAC5B;;;;;;OAMG;IACH,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACnC,wCAAwC;IACxC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAAA;IAC5B,4EAA4E;IAC5E,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAAA;IACpC,wFAAwF;IACxF,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAClC,4DAA4D;IAC5D,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACtC;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IAC/D;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;IACpD,oEAAoE;IACpE,sBAAsB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAA;IAC3C;;;;;;;OAOG;IACH,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACrD;;;;;;;;;;;;OAYG;IACH,2BAA2B,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAAA;IACnE;;;;;;OAMG;IACH,KAAK,EAAE,YAAY,CAAA;IACnB;;;;;;;;;OASG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,cAAc,EAAE,MAAM,CAAA;IACtB,uEAAuE;IACvE,eAAe,EAAE,MAAM,CAAA;IACvB,4IAA4I;IAC5I,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;;;;;OAOG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,kBAAkB,CAAA;IAChC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACvD;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,CAAA;IAC7C;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAClC;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IAC/C;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IAClD,2FAA2F;IAC3F,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjD;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IAC9C;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,eAAe,GAAG,IAAI,CAAA;IAC7C;;;OAGG;IACH,4BAA4B,CAAC,EAAE,eAAe,GAAG,IAAI,CAAA;CACtD;AAshBD,yFAAyF;AACzF,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,gBAAgB,CA2ClF;AA2VD,wBAAgB,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAchE;AAshFD;;;;GAIG;AACH,KAAK,qBAAqB,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,UAAU,CAAA;IACtB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AA68BD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC;;;;OAIG;IACH,SAAS,EAAE,EAAE,CAAC,UAAU,CAAA;IACxB,eAAe,EAAE,qBAAqB,GAAG,SAAS,CAAA;IAClD,cAAc,EAAE,UAAU,GAAG,SAAS,CAAA;IACtC,UAAU,EAAE,aAAa,GAAG,aAAa,GAAG,SAAS,CAAA;IACrD,cAAc,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IAC9C,eAAe,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAA;CAC3D;AA6JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,EAAE,CAAC,cAAc,EACvB,GAAG,EAAE,gBAAgB,EACrB,YAAY,EAAE,OAAO,GACpB,cAAc,CA8BhB;AAED,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,aAAa,EAAE,gBAAgB,EAAE,GAAG,SAAS,CAAA;IAC7C,oFAAoF;IACpF,YAAY,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,CAAA;CAClC;AAgDD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,EAAE,CAAC,aAAa,EAC1B,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,gBAAgB,GAAG,iBAAiB,CAAC,EAClE,GAAG,EAAE,gBAAgB,GACpB,aAAa,CAsCf;AAED,iDAAiD;AACjD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB;;;;OAIG;IACH,QAAQ,EAAE,mBAAmB,GAAG,SAAS,CAAA;IACzC,eAAe,EAAE,eAAe,GAAG,SAAS,CAAA;CAC7C;AAkfD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,GAAG,EAAE,gBAAgB,EACrB,GAAG,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,GAAG,OAAO,GAAG,eAAe,CAAC,EAC7D,EAAE,EAAE,CAAC,UAAU,EAAE,YAAY,KAAK,CAAC,GAClC,CAAC,CAUH;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,EAAE,CAAC,aAAa,EAC1B,GAAG,EAAE,aAAa,EAClB,UAAU,EAAE,YAAY,EACxB,GAAG,EAAE,gBAAgB,EACrB,YAAY,EAAE,OAAO,EACrB,MAAM,EAAE,KAAK,GAAG,SAAS,GACxB,gBAAgB,CAOlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,EAAE,CAAC,cAAc,EACvB,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,KAAK,GAAG,SAAS,EACzB,gBAAgB,EAAE,MAAM,GACvB,IAAI,CAwBN;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,qBAAqB,EAAE,OAAO,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,EAAE,CAAC,aAAa,EAC1B,QAAQ,EAAE,MAAM,EAAE,EAClB,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,GACZ,WAAW,CAmBb;AAiCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,EAAE,CAAC,cAAc,EACvB,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,EAAE,mBAAmB,GAAG,SAAS,EACzC,GAAG,EAAE,gBAAgB,GACpB,mBAAmB,GAAG,SAAS,CAkBjC;AAuBD,oFAAoF;AACpF,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,OAAO,CAAA;IACtB,QAAQ,EAAE,OAAO,CAAA;IACjB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,aAAa,EAAE,OAAO,CAAA;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,GAAG,WAAW,GAAG,iBAAiB,CAAC,EACvE,MAAM,EAAE,KAAK,GAAG,SAAS,EACzB,GAAG,EAAE,gBAAgB,GACpB,uBAAuB,CAUzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,EAAE,mBAAmB,GAAG,SAAS,EACzC,aAAa,EAAE,OAAO,EACtB,GAAG,EAAE,gBAAgB,GACpB,oBAAoB,EAAE,GAAG,SAAS,CASpC;AAw4CD,8DAA8D;AAC9D,UAAU,cAAc;IACtB,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAA;IACf,wEAAwE;IACxE,MAAM,EAAE,YAAY,EAAE,CAAA;CACvB;AAED,UAAU,YAAY;IACpB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,EAAE,CAAC,IAAI,CAAA;CACd"}
|
|
@@ -49,7 +49,15 @@ export interface NullishAttrContext {
|
|
|
49
49
|
/** Signals seeded with a literal `null`: their SSR value is `null`, not
|
|
50
50
|
* `undefined` (`arithmeticOperandIsNull`). */
|
|
51
51
|
readonly nullSeededSignals?: ReadonlySet<string>;
|
|
52
|
+
/** Signals seeded with `undefined` (`createSignal(undefined)` or a
|
|
53
|
+
* zero-arg `createSignal()`): their SSR value is `undefined`, not `null`
|
|
54
|
+
* (`arithmeticOperandIsUndefined`). */
|
|
55
|
+
readonly undefinedSeededSignals?: ReadonlySet<string>;
|
|
52
56
|
readonly memos: ReadonlyMap<string, MemoInfo>;
|
|
57
|
+
/** Props declared as a number that may be `null` or absent (`n: number |
|
|
58
|
+
* null`, `n?: number`), by the name a read uses: the binding name, and
|
|
59
|
+
* `<propsObjectName>.<key>` for a member read (#3474). */
|
|
60
|
+
readonly nullableNumberProps?: ReadonlySet<string>;
|
|
53
61
|
}
|
|
54
62
|
export declare function collectNullishAttrContext(ir: ComponentIR): NullishAttrContext;
|
|
55
63
|
/**
|
|
@@ -83,6 +91,14 @@ export declare function attrValueMayBeNullish(parsed: ParsedExpr | undefined, ct
|
|
|
83
91
|
* `s` before the adapter sees it.
|
|
84
92
|
*/
|
|
85
93
|
export declare function arithmeticOperandIsNull(parsed: ParsedExpr | undefined, ctx: NullishAttrContext, isShadowed?: (name: string) => boolean): boolean;
|
|
94
|
+
/**
|
|
95
|
+
* Whether an arithmetic operand's SSR value is certainly `undefined` — the
|
|
96
|
+
* literal `undefined`, a read of a signal seeded with `undefined` (or a
|
|
97
|
+
* zero-arg `createSignal()`), or a memo whose body is such a read. JS
|
|
98
|
+
* `ToNumber(undefined)` is `NaN`, so adapters coerce such an operand with
|
|
99
|
+
* their JS `Number()` helper, which maps the engine's nil to `NaN` (#3390).
|
|
100
|
+
*/
|
|
101
|
+
export declare function arithmeticOperandIsUndefined(parsed: ParsedExpr | undefined, ctx: NullishAttrContext, isShadowed?: (name: string) => boolean): boolean;
|
|
86
102
|
/**
|
|
87
103
|
* Arithmetic operators JS applies `ToNumber` to, so a `null` operand reads
|
|
88
104
|
* as `0` (`null * 2` is `0`). A template engine's native operator rejects a
|
|
@@ -91,4 +107,19 @@ export declare function arithmeticOperandIsNull(parsed: ParsedExpr | undefined,
|
|
|
91
107
|
* concatenates when either side is a string.
|
|
92
108
|
*/
|
|
93
109
|
export declare const NULL_COERCING_ARITHMETIC_OPS: ReadonlySet<string>;
|
|
110
|
+
/** How a DSL adapter coerces an arithmetic operand (#3474): `'null'` reads a
|
|
111
|
+
* nil as `0` (JS `ToNumber(null)`), `'undefined'` reads it as `NaN`
|
|
112
|
+
* (`ToNumber(undefined)`), `null` leaves the operand as is. */
|
|
113
|
+
export type ArithmeticCoercion = 'null' | 'undefined' | null;
|
|
114
|
+
/**
|
|
115
|
+
* The one decision behind every DSL adapter's arithmetic over a nullish
|
|
116
|
+
* operand (#3474). An operand known to be `null` / `undefined`
|
|
117
|
+
* (`arithmeticOperandIsNull` / `arithmeticOperandIsUndefined`, or a nullable
|
|
118
|
+
* number prop) is coerced under the operators JS applies `ToNumber` to
|
|
119
|
+
* ({@link NULL_COERCING_ARITHMETIC_OPS}), and under `+` when the other
|
|
120
|
+
* operand is a number literal, where `+` cannot concatenate. Each adapter
|
|
121
|
+
* only spells the coercion; one whose engine already reads nil as `0`
|
|
122
|
+
* spells `'null'` as the operand itself.
|
|
123
|
+
*/
|
|
124
|
+
export declare function arithmeticOperandCoercion(op: string, operand: ParsedExpr | undefined, other: ParsedExpr | undefined, ctx: NullishAttrContext, isShadowed?: (name: string) => boolean): ArithmeticCoercion;
|
|
94
125
|
//# sourceMappingURL=nullable-signal-attr.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"nullable-signal-attr.d.ts","sourceRoot":"","sources":["../src/nullable-signal-attr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAY,MAAM,YAAY,CAAA;AAY7E,sDAAsD;AACtD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAItE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAG5D;AAED,8EAA8E;AAC9E,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAGhF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAC5B,MAAM,GAAG,IAAI,CAGf;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC7C;kDAC8C;IAC9C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAChD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;
|
|
1
|
+
{"version":3,"file":"nullable-signal-attr.d.ts","sourceRoot":"","sources":["../src/nullable-signal-attr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAY,MAAM,YAAY,CAAA;AAY7E,sDAAsD;AACtD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAItE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAG5D;AAED,8EAA8E;AAC9E,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAGhF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAC5B,MAAM,GAAG,IAAI,CAGf;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC7C;kDAC8C;IAC9C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAChD;;2CAEuC;IACvC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACrD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC7C;;8DAE0D;IAC1D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACnD;AAED,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,WAAW,GAAG,kBAAkB,CAa7E;AAuBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,GAAG,EAAE,kBAAkB,EACvB,UAAU,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAqB,GAClD,OAAO,CAsCT;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,GAAG,EAAE,kBAAkB,EACvB,UAAU,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAqB,GAClD,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,GAAG,EAAE,kBAAkB,EACvB,UAAU,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAqB,GAClD,OAAO,CAET;AA8CD;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,MAAM,CAAuC,CAAA;AAEpG;;+DAE+D;AAC/D,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,WAAW,GAAG,IAAI,CAAA;AAE5D;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,UAAU,GAAG,SAAS,EAC/B,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,GAAG,EAAE,kBAAkB,EACvB,UAAU,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAqB,GAClD,kBAAkB,CAGpB"}
|
|
@@ -118,6 +118,16 @@ export declare class BindingScope {
|
|
|
118
118
|
* parameter list) with source `'param'`. Parent is not mutated.
|
|
119
119
|
*/
|
|
120
120
|
enterCallback(params: readonly string[]): BindingScope;
|
|
121
|
+
/**
|
|
122
|
+
* Child scope with a `'callback'` frame binding each alias to the binding
|
|
123
|
+
* its original name resolves to here (same source and string typing). An
|
|
124
|
+
* adapter that rewrites a `.filter()` predicate's captured names to
|
|
125
|
+
* loop-scoped aliases enters this while emitting the predicate, so the
|
|
126
|
+
* aliases render and type exactly like the names they stand for (#3402).
|
|
127
|
+
* Aliases whose original is unbound are skipped; returns `this` when none
|
|
128
|
+
* bind. Parent is not mutated.
|
|
129
|
+
*/
|
|
130
|
+
enterAliases(aliasToOriginal: ReadonlyMap<string, string>): BindingScope;
|
|
121
131
|
/** Innermost-first membership check across every frame in the stack. */
|
|
122
132
|
isBound(name: string): boolean;
|
|
123
133
|
/** Resolve string typing at this position, respecting the nearest binding. */
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"binding-scope.d.ts","sourceRoot":"","sources":["../../src/scope/binding-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,CAAA;AAExF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAA;IACtC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACrD;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,IAAI,CAAA;IACxC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC7D,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAA;CACzE;AAED,UAAU,aAAa;IACrB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAA;CAC/C;AAOD;;;;;;GAMG;AACH,qBAAa,YAAY;IAGH,OAAO,CAAC,QAAQ,CAAC,MAAM;IAF3C,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAuB;IAE1D,OAAO,eAA+D;IAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,YAAY,CAAC,IAAI,EAAE,iBAAiB,GAAG,YAAY,CAelD;IAED;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAKrD;IAED,wEAAwE;IACxE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAK7B;IAED,8EAA8E;IAC9E,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAAE,iBAAiB,UAAQ,GAAG,OAAO,CAIpG;IAED,mEAAmE;IACnE,aAAa,IAAI,SAAS,MAAM,EAAE,CAKjC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,IAAI,CAOlH;IAED;;;;;;;;OAQG;IACH,UAAU,IAAI,WAAW,CAAC,MAAM,CAAC,CAQhC;IAMD,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,oBAAoB,CAAiC;IAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,eAAe,IAAI,WAAW,CAAC,MAAM,CAAC,CAYrC;IAED;;;OAGG;IACH,iBAAiB,IAAI,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAE7C;CACF"}
|
|
1
|
+
{"version":3,"file":"binding-scope.d.ts","sourceRoot":"","sources":["../../src/scope/binding-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,CAAA;AAExF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAA;IACtC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACrD;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,IAAI,CAAA;IACxC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC7D,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAA;CACzE;AAED,UAAU,aAAa;IACrB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAA;CAC/C;AAOD;;;;;;GAMG;AACH,qBAAa,YAAY;IAGH,OAAO,CAAC,QAAQ,CAAC,MAAM;IAF3C,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAuB;IAE1D,OAAO,eAA+D;IAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,YAAY,CAAC,IAAI,EAAE,iBAAiB,GAAG,YAAY,CAelD;IAED;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAKrD;IAED;;;;;;;;OAQG;IACH,YAAY,CAAC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAQvE;IAED,wEAAwE;IACxE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAK7B;IAED,8EAA8E;IAC9E,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAAE,iBAAiB,UAAQ,GAAG,OAAO,CAIpG;IAED,mEAAmE;IACnE,aAAa,IAAI,SAAS,MAAM,EAAE,CAKjC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;KAAE,GAAG,IAAI,CAOlH;IAED;;;;;;;;OAQG;IACH,UAAU,IAAI,WAAW,CAAC,MAAM,CAAC,CAQhC;IAMD,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,oBAAoB,CAAiC;IAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,eAAe,IAAI,WAAW,CAAC,MAAM,CAAC,CAYrC;IAED;;;OAGG;IACH,iBAAiB,IAAI,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAE7C;CACF"}
|
package/dist/types.d.ts
CHANGED
|
@@ -974,6 +974,13 @@ export interface LoopParamBinding {
|
|
|
974
974
|
* reading it as "binding at the loop root".
|
|
975
975
|
*/
|
|
976
976
|
segments?: readonly LoopBindingPathSegment[];
|
|
977
|
+
/**
|
|
978
|
+
* Client JS only: the row accessor call this binding reads through
|
|
979
|
+
* (`__bfItem_l0()`), set on the bindings of a nested destructured `.map()`
|
|
980
|
+
* row so its render callback does not shadow an enclosing row's
|
|
981
|
+
* `__bfItem` (#3397). Absent for a top-level row, which reads `__bfItem()`.
|
|
982
|
+
*/
|
|
983
|
+
accessor?: string;
|
|
977
984
|
}
|
|
978
985
|
export interface IRComponent {
|
|
979
986
|
type: 'component';
|