@barefootjs/jsx 0.39.7 → 0.39.9
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/callback-method.d.ts +36 -7
- package/dist/adapters/callback-method.d.ts.map +1 -1
- package/dist/adapters/component-props.d.ts +80 -13
- package/dist/adapters/component-props.d.ts.map +1 -1
- package/dist/adapters/dsl-template-adapter.d.ts +153 -0
- package/dist/adapters/dsl-template-adapter.d.ts.map +1 -0
- package/dist/adapters/jsx-adapter.d.ts +4 -0
- package/dist/adapters/jsx-adapter.d.ts.map +1 -1
- package/dist/adapters/literal-value.d.ts +2 -2
- package/dist/adapters/literal-value.d.ts.map +1 -1
- package/dist/adapters/loop-plan.d.ts +133 -9
- package/dist/adapters/loop-plan.d.ts.map +1 -1
- package/dist/adapters/parsed-expr-emitter.d.ts +44 -0
- package/dist/adapters/parsed-expr-emitter.d.ts.map +1 -1
- package/dist/adapters/style-object.d.ts +33 -0
- package/dist/adapters/style-object.d.ts.map +1 -0
- package/dist/analyzer.d.ts.map +1 -1
- package/dist/assignment-target.d.ts +26 -0
- package/dist/assignment-target.d.ts.map +1 -0
- package/dist/children-nullish.d.ts +22 -0
- package/dist/children-nullish.d.ts.map +1 -0
- package/dist/errors.d.ts +2 -0
- package/dist/errors.d.ts.map +1 -1
- package/dist/expression-parser.d.ts +9 -19
- package/dist/expression-parser.d.ts.map +1 -1
- package/dist/free-refs.d.ts +6 -0
- package/dist/free-refs.d.ts.map +1 -1
- package/dist/index.d.ts +17 -14
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +15040 -13899
- package/dist/ir-to-client-js/compute-inlinability.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/plan/build-component-loop.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/plan/event-collision.d.ts +2 -1
- package/dist/ir-to-client-js/control-flow/plan/event-collision.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/plan/insert.d.ts +2 -2
- package/dist/ir-to-client-js/control-flow/plan/insert.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/plan/loop.d.ts +24 -1
- package/dist/ir-to-client-js/control-flow/plan/loop.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/shared.d.ts +16 -1
- package/dist/ir-to-client-js/control-flow/shared.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/stringify/component-loop.d.ts +6 -1
- package/dist/ir-to-client-js/control-flow/stringify/component-loop.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/stringify/event-delegation.d.ts.map +1 -1
- package/dist/ir-to-client-js/control-flow/stringify/event-listener.d.ts +10 -9
- package/dist/ir-to-client-js/control-flow/stringify/event-listener.d.ts.map +1 -1
- package/dist/ir-to-client-js/csr-substitute.d.ts +13 -2
- package/dist/ir-to-client-js/csr-substitute.d.ts.map +1 -1
- package/dist/ir-to-client-js/emit-reactive.d.ts +1 -1
- package/dist/ir-to-client-js/emit-reactive.d.ts.map +1 -1
- package/dist/ir-to-client-js/emit-registration.d.ts +10 -8
- package/dist/ir-to-client-js/emit-registration.d.ts.map +1 -1
- package/dist/ir-to-client-js/generate-init.d.ts.map +1 -1
- package/dist/ir-to-client-js/html-template.d.ts +0 -9
- package/dist/ir-to-client-js/html-template.d.ts.map +1 -1
- package/dist/ir-to-client-js/identifiers.d.ts +6 -8
- package/dist/ir-to-client-js/identifiers.d.ts.map +1 -1
- package/dist/ir-to-client-js/imports.d.ts +23 -2
- package/dist/ir-to-client-js/imports.d.ts.map +1 -1
- package/dist/ir-to-client-js/phases/props-extraction.d.ts +6 -3
- package/dist/ir-to-client-js/phases/props-extraction.d.ts.map +1 -1
- package/dist/ir-to-client-js/plan/static-array-child-init.d.ts +8 -0
- package/dist/ir-to-client-js/plan/static-array-child-init.d.ts.map +1 -1
- package/dist/ir-to-client-js/prune-unused-prop-extractions.d.ts +1 -1
- package/dist/ir-to-client-js/prune-unused-prop-extractions.d.ts.map +1 -1
- package/dist/ir-to-client-js/reactivity.d.ts.map +1 -1
- package/dist/ir-to-client-js/rewrite-destructured-props.d.ts +1 -1
- package/dist/ir-to-client-js/rewrite-destructured-props.d.ts.map +1 -1
- package/dist/ir-to-client-js/rewrite-props-object.d.ts.map +1 -1
- package/dist/ir-to-client-js/safe-html.d.ts +20 -2
- package/dist/ir-to-client-js/safe-html.d.ts.map +1 -1
- package/dist/ir-to-client-js/stringify/static-array-child-init.d.ts +1 -0
- package/dist/ir-to-client-js/stringify/static-array-child-init.d.ts.map +1 -1
- package/dist/ir-to-client-js/types.d.ts +3 -3
- package/dist/ir-to-client-js/types.d.ts.map +1 -1
- package/dist/ir-to-client-js/utils.d.ts +2 -11
- package/dist/ir-to-client-js/utils.d.ts.map +1 -1
- package/dist/jsx-to-ir.d.ts.map +1 -1
- package/dist/nullable-signal-attr.d.ts +40 -10
- package/dist/nullable-signal-attr.d.ts.map +1 -1
- package/dist/prop-rewrite.d.ts +35 -8
- package/dist/prop-rewrite.d.ts.map +1 -1
- package/dist/props-binding.d.ts +66 -1
- package/dist/props-binding.d.ts.map +1 -1
- package/dist/scanner/js-scanner.d.ts.map +1 -1
- package/dist/scanner/js-scanner.js +30 -2
- package/dist/scope/binding-scope.d.ts +30 -2
- package/dist/scope/binding-scope.d.ts.map +1 -1
- package/dist/scope/lexical-scope-walk.d.ts +26 -0
- package/dist/scope/lexical-scope-walk.d.ts.map +1 -0
- package/dist/signal-prop-name-collision.d.ts +6 -5
- package/dist/signal-prop-name-collision.d.ts.map +1 -1
- package/dist/ssr-defaults.d.ts +28 -0
- package/dist/ssr-defaults.d.ts.map +1 -1
- package/dist/ssr-seed-plan.d.ts +39 -14
- package/dist/ssr-seed-plan.d.ts.map +1 -1
- package/dist/types.d.ts +133 -19
- package/dist/types.d.ts.map +1 -1
- package/dist/value-references.d.ts +21 -0
- package/dist/value-references.d.ts.map +1 -1
- package/package.json +2 -2
- package/src/__tests__/__snapshots__/doc-examples.test.ts.snap +18 -18
- package/src/__tests__/adapter-output.test.ts +5 -3
- package/src/__tests__/analyzer.test.ts +33 -0
- package/src/__tests__/arithmetic-lowering.test.ts +48 -0
- package/src/__tests__/binding-scope.test.ts +29 -0
- package/src/__tests__/children-read.test.ts +226 -0
- package/src/__tests__/client-template-escape-soundness.test.ts +31 -1
- package/src/__tests__/component-props.test.ts +68 -1
- package/src/__tests__/constant-inlining-tree.test.ts +136 -0
- package/src/__tests__/create-query.test.ts +1 -1
- package/src/__tests__/destructure-default-reads-earlier-param.test.ts +138 -0
- package/src/__tests__/dsl-template-adapter.test.ts +173 -0
- package/src/__tests__/emit-to-string-call.test.ts +58 -0
- package/src/__tests__/event-handler-verbatim.test.ts +73 -0
- package/src/__tests__/expression-parser.test.ts +1 -44
- package/src/__tests__/loop-param-accessor-key-member-safety.test.ts +90 -31
- package/src/__tests__/loop-plan.test.ts +131 -1
- package/src/__tests__/loop-row-child-children-handler.test.ts +129 -0
- package/src/__tests__/loop-row-child-children-inner-loop-shadow.test.ts +74 -0
- package/src/__tests__/loop-row-child-children-ref.test.ts +117 -0
- package/src/__tests__/nullable-signal-attr.test.ts +67 -3
- package/src/__tests__/props-alias-const.test.ts +60 -1
- package/src/__tests__/props-named-callback-param.test.ts +256 -0
- package/src/__tests__/reference-graph-identifiers.test.ts +161 -0
- package/src/__tests__/renamed-body-destructure-template.test.ts +86 -0
- package/src/__tests__/rewrite-props-object.test.ts +90 -0
- package/src/__tests__/runtime-import-detection.test.ts +134 -0
- package/src/__tests__/signal-prop-name-collision.test.ts +30 -0
- package/src/__tests__/ssr-defaults.test.ts +19 -1
- package/src/__tests__/ssr-seed-plan.test.ts +119 -0
- package/src/__tests__/style-object-plan.test.ts +54 -0
- package/src/__tests__/written-binding-substitution.test.ts +430 -0
- package/src/__tests__/zero-param-helper-inline.test.ts +57 -0
- package/src/adapters/callback-method.ts +48 -10
- package/src/adapters/component-props.ts +130 -12
- package/src/adapters/dsl-template-adapter.ts +259 -0
- package/src/adapters/jsx-adapter.ts +12 -6
- package/src/adapters/literal-value.ts +2 -2
- package/src/adapters/loop-plan.ts +201 -13
- package/src/adapters/parsed-expr-emitter.ts +67 -0
- package/src/adapters/style-object.ts +61 -0
- package/src/analyzer.ts +396 -16
- package/src/assignment-target.ts +79 -0
- package/src/children-nullish.ts +33 -0
- package/src/debug.ts +2 -2
- package/src/errors.ts +23 -0
- package/src/expression-parser.ts +56 -53
- package/src/free-refs.ts +28 -17
- package/src/index.ts +31 -10
- package/src/ir-to-client-js/compute-inlinability.ts +35 -5
- package/src/ir-to-client-js/control-flow/plan/build-component-loop.ts +21 -5
- package/src/ir-to-client-js/control-flow/plan/event-collision.ts +2 -1
- package/src/ir-to-client-js/control-flow/plan/insert.ts +2 -2
- package/src/ir-to-client-js/control-flow/plan/loop.ts +25 -1
- package/src/ir-to-client-js/control-flow/shared.ts +41 -3
- package/src/ir-to-client-js/control-flow/stringify/component-loop.ts +23 -3
- package/src/ir-to-client-js/control-flow/stringify/event-delegation.ts +3 -2
- package/src/ir-to-client-js/control-flow/stringify/event-listener.ts +13 -12
- package/src/ir-to-client-js/csr-substitute.ts +82 -24
- package/src/ir-to-client-js/emit-reactive.ts +3 -3
- package/src/ir-to-client-js/emit-registration.ts +34 -58
- package/src/ir-to-client-js/generate-init.ts +17 -1
- package/src/ir-to-client-js/html-template.ts +48 -57
- package/src/ir-to-client-js/identifiers.ts +75 -24
- package/src/ir-to-client-js/imports.ts +56 -19
- package/src/ir-to-client-js/index.ts +2 -1
- package/src/ir-to-client-js/phases/event-handlers.ts +2 -2
- package/src/ir-to-client-js/phases/props-extraction.ts +39 -17
- package/src/ir-to-client-js/plan/build-declaration-emit.ts +2 -2
- package/src/ir-to-client-js/plan/build-static-array-child-init.ts +7 -0
- package/src/ir-to-client-js/plan/static-array-child-init.ts +8 -0
- package/src/ir-to-client-js/prune-unused-prop-extractions.ts +7 -4
- package/src/ir-to-client-js/reactivity.ts +2 -2
- package/src/ir-to-client-js/rewrite-destructured-props.ts +22 -5
- package/src/ir-to-client-js/rewrite-props-object.ts +14 -8
- package/src/ir-to-client-js/safe-html.ts +29 -35
- package/src/ir-to-client-js/stringify/static-array-child-init.ts +4 -1
- package/src/ir-to-client-js/types.ts +3 -2
- package/src/ir-to-client-js/utils.ts +42 -122
- package/src/jsx-to-ir.ts +310 -90
- package/src/nullable-signal-attr.ts +149 -33
- package/src/prop-rewrite.ts +72 -72
- package/src/props-binding.ts +90 -3
- package/src/scanner/__tests__/js-scanner.test.ts +37 -0
- package/src/scanner/js-scanner.ts +64 -4
- package/src/scope/binding-scope.ts +34 -3
- package/src/scope/lexical-scope-walk.ts +167 -0
- package/src/signal-prop-name-collision.ts +50 -24
- package/src/ssr-defaults.ts +47 -20
- package/src/ssr-seed-plan.ts +103 -23
- package/src/types.ts +140 -20
- package/src/value-references.ts +132 -0
|
@@ -4,11 +4,14 @@ function* iterateJsTokens(text, start = 0, end = text.length) {
|
|
|
4
4
|
const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, text, undefined, start, end - start);
|
|
5
5
|
const templateStack = [];
|
|
6
6
|
let prevSignificant;
|
|
7
|
+
let regexMayStart = true;
|
|
8
|
+
const parens = [];
|
|
9
|
+
let beforePrev;
|
|
7
10
|
while (true) {
|
|
8
11
|
let kind = scanner.scan();
|
|
9
12
|
if (kind === ts.SyntaxKind.EndOfFileToken)
|
|
10
13
|
break;
|
|
11
|
-
if ((kind === ts.SyntaxKind.SlashToken || kind === ts.SyntaxKind.SlashEqualsToken) &&
|
|
14
|
+
if ((kind === ts.SyntaxKind.SlashToken || kind === ts.SyntaxKind.SlashEqualsToken) && regexMayStart) {
|
|
12
15
|
kind = scanner.reScanSlashToken();
|
|
13
16
|
}
|
|
14
17
|
if (kind === ts.SyntaxKind.CloseBraceToken && templateStack.length > 0 && templateStack[templateStack.length - 1].braceDepth === 0) {
|
|
@@ -29,10 +32,35 @@ function* iterateJsTokens(text, start = 0, end = text.length) {
|
|
|
29
32
|
top.braceDepth--;
|
|
30
33
|
}
|
|
31
34
|
yield { kind, pos: scanner.getTokenStart(), end: scanner.getTokenEnd() };
|
|
32
|
-
if (!isTriviaKind(kind))
|
|
35
|
+
if (!isTriviaKind(kind)) {
|
|
36
|
+
trackForHeaderParens(parens, kind, prevSignificant, beforePrev);
|
|
37
|
+
regexMayStart = regexAfter(kind, prevSignificant, parens[parens.length - 1] === true);
|
|
38
|
+
beforePrev = prevSignificant;
|
|
33
39
|
prevSignificant = kind;
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
function trackForHeaderParens(parens, kind, prev, beforePrev) {
|
|
44
|
+
if (kind === ts.SyntaxKind.OpenParenToken) {
|
|
45
|
+
parens.push(prev === ts.SyntaxKind.ForKeyword || prev === ts.SyntaxKind.AwaitKeyword && beforePrev === ts.SyntaxKind.ForKeyword);
|
|
46
|
+
} else if (kind === ts.SyntaxKind.CloseParenToken) {
|
|
47
|
+
parens.pop();
|
|
34
48
|
}
|
|
35
49
|
}
|
|
50
|
+
function regexAfter(kind, before, inForHeader) {
|
|
51
|
+
if (kind >= ts.SyntaxKind.FirstKeyword && kind <= ts.SyntaxKind.LastKeyword) {
|
|
52
|
+
if (before === ts.SyntaxKind.DotToken || before === ts.SyntaxKind.QuestionDotToken)
|
|
53
|
+
return false;
|
|
54
|
+
if (kind === ts.SyntaxKind.OfKeyword && inForHeader && endsBinding(before))
|
|
55
|
+
return true;
|
|
56
|
+
if (kind > ts.SyntaxKind.LastFutureReservedWord && kind !== ts.SyntaxKind.AwaitKeyword)
|
|
57
|
+
return false;
|
|
58
|
+
}
|
|
59
|
+
return canRegexStartHere(kind);
|
|
60
|
+
}
|
|
61
|
+
function endsBinding(before) {
|
|
62
|
+
return before === ts.SyntaxKind.Identifier || before === ts.SyntaxKind.CloseBracketToken || before === ts.SyntaxKind.CloseBraceToken || before !== undefined && before > ts.SyntaxKind.LastFutureReservedWord && before <= ts.SyntaxKind.LastKeyword;
|
|
63
|
+
}
|
|
36
64
|
function isTriviaKind(kind) {
|
|
37
65
|
return kind === ts.SyntaxKind.WhitespaceTrivia || kind === ts.SyntaxKind.NewLineTrivia || kind === ts.SyntaxKind.SingleLineCommentTrivia || kind === ts.SyntaxKind.MultiLineCommentTrivia || kind === ts.SyntaxKind.ShebangTrivia || kind === ts.SyntaxKind.ConflictMarkerTrivia;
|
|
38
66
|
}
|
|
@@ -38,6 +38,17 @@ export type ScopeBindingSource = 'item' | 'index' | 'destructure' | 'preamble' |
|
|
|
38
38
|
export interface ScopeBinding {
|
|
39
39
|
readonly source: ScopeBindingSource;
|
|
40
40
|
readonly stringValue?: boolean;
|
|
41
|
+
/**
|
|
42
|
+
* The row a `'item'` / `'destructure'` binding reads: the loop's item type
|
|
43
|
+
* and the accessor path from the item to the binding (empty for the plain
|
|
44
|
+
* item). Absent when the loop has no item type or the binding is a rest
|
|
45
|
+
* element. Lets a typed backend resolve the type of a row read
|
|
46
|
+
* (`row.id`, a destructured `id`) at the read.
|
|
47
|
+
*/
|
|
48
|
+
readonly row?: {
|
|
49
|
+
readonly itemType: LoopValueType;
|
|
50
|
+
readonly segments: readonly RowPathSegment[];
|
|
51
|
+
};
|
|
41
52
|
}
|
|
42
53
|
export interface ScopeFrame {
|
|
43
54
|
readonly kind: 'loop-row' | 'callback';
|
|
@@ -52,18 +63,36 @@ export interface ScopeFrame {
|
|
|
52
63
|
export interface LoopBindingSource {
|
|
53
64
|
readonly param: string;
|
|
54
65
|
readonly itemType?: LoopValueType | null;
|
|
66
|
+
/**
|
|
67
|
+
* The item type a binding's `row` carries, when the caller knows more than
|
|
68
|
+
* `itemType` (which is scalar evidence only): a backend that resolves an
|
|
69
|
+
* object row's type from the loop's array source. Defaults to `itemType`.
|
|
70
|
+
*/
|
|
71
|
+
readonly rowType?: LoopValueType | null;
|
|
55
72
|
readonly index?: string | null;
|
|
56
73
|
readonly paramBindings?: readonly {
|
|
57
74
|
readonly name: string;
|
|
75
|
+
readonly segments?: readonly RowPathSegment[];
|
|
76
|
+
readonly rest?: unknown;
|
|
58
77
|
}[];
|
|
59
78
|
readonly preamble?: {
|
|
60
79
|
readonly declaredNames: readonly string[];
|
|
61
80
|
} | null;
|
|
62
81
|
}
|
|
63
|
-
|
|
82
|
+
/** Structural pick of `TypeInfo` (`packages/jsx/src/types.ts`). */
|
|
83
|
+
export interface LoopValueType {
|
|
64
84
|
readonly primitive?: string;
|
|
65
85
|
readonly unionTypes?: readonly LoopValueType[];
|
|
66
86
|
}
|
|
87
|
+
/** Structural copy of `LoopBindingPathSegment` (`packages/jsx/src/types.ts`). */
|
|
88
|
+
export type RowPathSegment = {
|
|
89
|
+
readonly kind: 'field';
|
|
90
|
+
readonly key: string;
|
|
91
|
+
readonly isIdent: boolean;
|
|
92
|
+
} | {
|
|
93
|
+
readonly kind: 'index';
|
|
94
|
+
readonly index: number;
|
|
95
|
+
};
|
|
67
96
|
/**
|
|
68
97
|
* A stack of `ScopeFrame`s, innermost frame at index 0 of the internal
|
|
69
98
|
* array (i.e. `frames[0]` is what `enterLoopRow`/`enterCallback` most
|
|
@@ -196,5 +225,4 @@ export declare class BindingScope {
|
|
|
196
225
|
*/
|
|
197
226
|
asShadowPredicate(): (name: string) => boolean;
|
|
198
227
|
}
|
|
199
|
-
export {};
|
|
200
228
|
//# sourceMappingURL=binding-scope.d.ts.map
|
|
@@ -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;
|
|
1
|
+
{"version":3,"file":"binding-scope.d.ts","sourceRoot":"","sources":["../../src/scope/binding-scope.ts"],"names":[],"mappings":"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"}
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Lexical binding frames for TS-AST walks over emitted or source JS text.
|
|
3
|
+
*
|
|
4
|
+
* Scope model: a name bound INSIDE the walked node — a nested arrow /
|
|
5
|
+
* function parameter, a block-scoped declaration, a `for` head's `let` /
|
|
6
|
+
* `const`, a catch variable — refers to that binding, not to an outer
|
|
7
|
+
* name of the same spelling, for the whole binding's scope. Names bound
|
|
8
|
+
* OUTSIDE the walked text (a loop callback that encloses a template
|
|
9
|
+
* fragment) are the caller's job — that is what `BindingScope`
|
|
10
|
+
* (`./binding-scope.ts`) answers; this module answers the complementary
|
|
11
|
+
* question for binders that live inside the text itself.
|
|
12
|
+
*
|
|
13
|
+
* Shared by the prop-reference rewrites in `prop-rewrite.ts`, the
|
|
14
|
+
* props-object rename in `ir-to-client-js/rewrite-props-object.ts` and the
|
|
15
|
+
* loop-param accessor rewrite in `ir-to-client-js/utils.ts`
|
|
16
|
+
* (`rewriteIdentifierReferences`, #3595), so all of them agree on which
|
|
17
|
+
* identifiers an inner binding shadows.
|
|
18
|
+
*/
|
|
19
|
+
import ts from 'typescript';
|
|
20
|
+
/**
|
|
21
|
+
* Depth-first walk that maintains the binding stack described above and
|
|
22
|
+
* reports every identifier along with whether a binding within `root`
|
|
23
|
+
* currently shadows it.
|
|
24
|
+
*/
|
|
25
|
+
export declare function walkWithScope(root: ts.Node, visit: (ident: ts.Identifier, parent: ts.Node | undefined, shadowed: boolean) => void): void;
|
|
26
|
+
//# sourceMappingURL=lexical-scope-walk.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"lexical-scope-walk.d.ts","sourceRoot":"","sources":["../../src/scope/lexical-scope-walk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AAyH3B;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,GACpF,IAAI,CAkBN"}
|
|
@@ -4,10 +4,11 @@ import type { AnalyzerContext } from './analyzer-context.ts';
|
|
|
4
4
|
* when one root's source changes. Other SourceFiles remain untouched. */
|
|
5
5
|
export declare function programWithSeparatedSource(program: ts.Program, filePath: string, source: string): ts.Program;
|
|
6
6
|
/**
|
|
7
|
-
* A
|
|
8
|
-
*
|
|
9
|
-
*
|
|
10
|
-
*
|
|
7
|
+
* A prop and a signal getter or memo of the same name are different JS
|
|
8
|
+
* bindings (`props.label` and `label()`), but scalar template backends
|
|
9
|
+
* flatten both to one variable. Give the local binding a hygienic name
|
|
10
|
+
* before building IR, so every backend (including the client emitter)
|
|
11
|
+
* receives one consistent binding identity.
|
|
11
12
|
*
|
|
12
13
|
* Source edits are AST/symbol-based and preserve untouched source bytes.
|
|
13
14
|
* Property keys, strings, and shadowing callback bindings never rename;
|
|
@@ -16,5 +17,5 @@ export declare function programWithSeparatedSource(program: ts.Program, filePath
|
|
|
16
17
|
* fallback binds the already-parsed SourceFile without parsing or loading
|
|
17
18
|
* dependencies: only lexical symbol identity is needed, not types.
|
|
18
19
|
*/
|
|
19
|
-
export declare function
|
|
20
|
+
export declare function separateSignalPropBindings(ctx: AnalyzerContext, isNonReference: (id: ts.Identifier) => boolean): string | null;
|
|
20
21
|
//# sourceMappingURL=signal-prop-name-collision.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"signal-prop-name-collision.d.ts","sourceRoot":"","sources":["../src/signal-prop-name-collision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;
|
|
1
|
+
{"version":3,"file":"signal-prop-name-collision.d.ts","sourceRoot":"","sources":["../src/signal-prop-name-collision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAc5D;yEACyE;AACzE,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,OAAO,CAgD5G;AAqCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,KAAK,OAAO,GAC7C,MAAM,GAAG,IAAI,CAqEf"}
|
package/dist/ssr-defaults.d.ts
CHANGED
|
@@ -90,4 +90,32 @@ export declare function deriveStashFromDefaults(defaults: Record<string, SsrDefa
|
|
|
90
90
|
* exposes no template variables (no props, no signals, no memos).
|
|
91
91
|
*/
|
|
92
92
|
export declare function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefault> | undefined;
|
|
93
|
+
/**
|
|
94
|
+
* Component-scope (non-module) `const` locals, by name → value source text.
|
|
95
|
+
* `referencesOwnProp` and `collectPropRefsTransitive` (below) use this to
|
|
96
|
+
* see PAST one hop of pure indirection between a prop read and the
|
|
97
|
+
* signal/memo that derives from it — `const mid = props.label;
|
|
98
|
+
* createSignal(mid ?? 'Default')` (#2685 review, one hop past #2669's
|
|
99
|
+
* direct-access-only detection). Module-scope consts are excluded: a
|
|
100
|
+
* MODULE const's value is fixed at compile time and isn't a `props.X` read
|
|
101
|
+
* (a module const referencing `props` isn't legal JS — `props` is a
|
|
102
|
+
* function parameter), so it can never contribute a prop reference here.
|
|
103
|
+
*/
|
|
104
|
+
export declare function localConstValuesByName(metadata: Pick<IRMetadata, 'localConstants'>): ReadonlyMap<string, string>;
|
|
105
|
+
/**
|
|
106
|
+
* Does `expr` (a signal initializer or memo computation) read
|
|
107
|
+
* `propsObjectName.<name>` where `name` is that SAME signal's getter / that
|
|
108
|
+
* SAME memo's name — directly, or through a chain of component-scope
|
|
109
|
+
* `const` locals? This is the #2669 self-derivation test (widened by
|
|
110
|
+
* #2685 review to see through indirection): reuses `collectPropRefsTransitive`
|
|
111
|
+
* (never a bespoke walker — see the CLAUDE.md rule this file already
|
|
112
|
+
* follows for `props.X` collection) and just checks membership of the one
|
|
113
|
+
* name we care about.
|
|
114
|
+
*
|
|
115
|
+
* Also the analyzer's test for which same-named signal/memo keeps sharing
|
|
116
|
+
* the prop's template variable (`separateSignalPropBindings`): a binding
|
|
117
|
+
* this answers `false` for is renamed before IR is built, so the two
|
|
118
|
+
* callers cannot disagree about which collisions stay collapsed.
|
|
119
|
+
*/
|
|
120
|
+
export declare function referencesOwnProp(expr: string | undefined, propsObjectName: string, name: string, localConsts: ReadonlyMap<string, string>): boolean;
|
|
93
121
|
//# sourceMappingURL=ssr-defaults.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"ssr-defaults.d.ts","sourceRoot":"","sources":["../src/ssr-defaults.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"ssr-defaults.d.ts","sourceRoot":"","sources":["../src/ssr-defaults.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG5C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzB;AAwDD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CAoP/F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAOhH;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,OAAO,CAIT"}
|
package/dist/ssr-seed-plan.d.ts
CHANGED
|
@@ -8,9 +8,11 @@
|
|
|
8
8
|
* template adapters' seed paths; this module computes it once, on the IR, so
|
|
9
9
|
* every adapter consumes the same plan and only supplies its own syntax.
|
|
10
10
|
*
|
|
11
|
-
* Ordering / acyclicity guarantee: `steps` lists the
|
|
12
|
-
*
|
|
13
|
-
*
|
|
11
|
+
* Ordering / acyclicity guarantee: `steps` lists the props whose destructure
|
|
12
|
+
* default reads an earlier prop first, in parameter order, then the
|
|
13
|
+
* component's signals, then its memos, each group in declaration order
|
|
14
|
+
* (matching `IRMetadata.signals` / `IRMetadata.memos`), then canonical getter
|
|
15
|
+
* aliases.
|
|
14
16
|
* A binding's name only enters
|
|
15
17
|
* the scope set AFTER its own step is decided, so a `derived` step's `frees`
|
|
16
18
|
* can only name `baseScope` entries or EARLIER steps — self- and
|
|
@@ -22,20 +24,21 @@
|
|
|
22
24
|
* literal value — `collectModuleStringConsts` is the shared source of that
|
|
23
25
|
* set — so a reference to one is never a template-variable read.
|
|
24
26
|
*
|
|
25
|
-
* A `derived` step
|
|
26
|
-
* `createSignal('b')`)
|
|
27
|
-
*
|
|
28
|
-
*
|
|
29
|
-
*
|
|
27
|
+
* A `derived` step whose `frees` name only module pure-string consts (or
|
|
28
|
+
* nothing, e.g. `createSignal('b')`) is a constant expression, marked
|
|
29
|
+
* `constant`: the plan still classifies it as derived because the expression
|
|
30
|
+
* is fully analyzable, and adapters keep their static ssr-defaults seed for
|
|
31
|
+
* it instead of computing it in-template. Likewise the plan makes no backend-specific choices —
|
|
30
32
|
* no target-variable checks, no self-shadowing rules, no per-backend shape
|
|
31
33
|
* catalogs — those stay in the adapters.
|
|
32
34
|
*/
|
|
33
35
|
import { type EnvSignalReader } from './adapters/env-signal.ts';
|
|
34
36
|
import { type ParsedExpr } from './expression-parser.ts';
|
|
35
|
-
import type { IRMetadata } from './types.ts';
|
|
37
|
+
import type { IRMetadata, ParamInfo } from './types.ts';
|
|
36
38
|
/**
|
|
37
|
-
* One binding in dependency order (signals, memos,
|
|
38
|
-
* matching `IRMetadata` order and the adapters'
|
|
39
|
+
* One binding in dependency order (dependent prop defaults, signals, memos,
|
|
40
|
+
* then getter aliases — matching `IRMetadata` order and the adapters'
|
|
41
|
+
* iteration).
|
|
39
42
|
*
|
|
40
43
|
* - `env-reader`: an env signal whose `envReader` key resolves in the shared
|
|
41
44
|
* registry (`envSignalReaderFor`). The runtime provides the per-request
|
|
@@ -44,7 +47,12 @@ import type { IRMetadata } from './types.ts';
|
|
|
44
47
|
* registry falls through to the normal derived/opaque rules instead.
|
|
45
48
|
* - `derived`: the binding's value expression is a supported shape whose free
|
|
46
49
|
* identifiers are all in scope at this point (baseScope + earlier steps) —
|
|
47
|
-
* an adapter may seed it in-template by lowering `parsed`/`expr`.
|
|
50
|
+
* an adapter may seed it in-template by lowering `parsed`/`expr`. An
|
|
51
|
+
* `origin: 'prop'` step re-binds a prop whose destructure default reads an
|
|
52
|
+
* earlier prop (`{ off = false, on = off }` → `on ?? off`, #3531): the
|
|
53
|
+
* static ssr-defaults seed cannot hold a value that depends on what the
|
|
54
|
+
* caller passed, so the template applies the default itself, reading the
|
|
55
|
+
* earlier prop's template variable.
|
|
48
56
|
* - `opaque`: not seedable this way (empty init, unsupported shape,
|
|
49
57
|
* unanalyzable free set, out-of-scope reference, or a block-bodied memo).
|
|
50
58
|
* The name still enters scope for later steps; adapters keep their static
|
|
@@ -57,14 +65,20 @@ export type SsrSeedStep = {
|
|
|
57
65
|
} | {
|
|
58
66
|
kind: 'derived';
|
|
59
67
|
name: string;
|
|
60
|
-
origin: 'signal' | 'memo';
|
|
68
|
+
origin: 'signal' | 'memo' | 'prop';
|
|
61
69
|
expr: string;
|
|
62
70
|
parsed: ParsedExpr;
|
|
63
71
|
frees: string[];
|
|
72
|
+
/**
|
|
73
|
+
* Every free identifier is a module pure-string const, which every
|
|
74
|
+
* adapter inlines, so the lowered expression reads no template
|
|
75
|
+
* variable (#3542).
|
|
76
|
+
*/
|
|
77
|
+
constant: boolean;
|
|
64
78
|
} | {
|
|
65
79
|
kind: 'opaque';
|
|
66
80
|
name: string;
|
|
67
|
-
origin: 'signal' | 'memo';
|
|
81
|
+
origin: 'signal' | 'memo' | 'prop';
|
|
68
82
|
};
|
|
69
83
|
export interface SsrSeedPlan {
|
|
70
84
|
/**
|
|
@@ -75,5 +89,16 @@ export interface SsrSeedPlan {
|
|
|
75
89
|
baseScope: string[];
|
|
76
90
|
steps: SsrSeedStep[];
|
|
77
91
|
}
|
|
92
|
+
/**
|
|
93
|
+
* `params` with every prop placed after the props its destructure default
|
|
94
|
+
* reads (`ParamInfo.defaultParts`). `propsParams` follows the props TYPE's
|
|
95
|
+
* member order for a body destructure (`const { a = 'x', b = a } = props`
|
|
96
|
+
* over `{ b?: string; a?: string }`), which need not be the pattern's order,
|
|
97
|
+
* so the order comes from the reads themselves. The reads only ever name an
|
|
98
|
+
* EARLIER binding of the same pattern, so they form no cycle; otherwise the
|
|
99
|
+
* input order is kept. Every backend applying these defaults one prop at a
|
|
100
|
+
* time (the in-template re-binds here, Go's constructor) uses this order.
|
|
101
|
+
*/
|
|
102
|
+
export declare function inDefaultReadOrder(params: readonly ParamInfo[]): ParamInfo[];
|
|
78
103
|
export declare function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan;
|
|
79
104
|
//# sourceMappingURL=ssr-seed-plan.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA
|
|
1
|
+
{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAGvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC7D;IACE,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAA;CAClB,GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAExE,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,WAAW,EAAE,CAAA;CACrB;AAiJD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAe5E;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAuFpE"}
|