@starci/eslint-canon-be 3.8.20 → 3.9.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +16 -0
- package/package.json +1 -1
- package/runtime/bundle.json +192 -0
- package/runtime/engine/by-code-unit.mjs +6 -6
- package/runtime/engine/model-config.mjs +98 -76
- package/runtime/engine/orca-config.mjs +22 -17
- package/runtime/engine/release-config.mjs +22 -18
- package/runtime/engine/removed-vocabulary.mjs +21 -20
- package/runtime/engine/resources-config.mjs +42 -35
- package/runtime/engine/runtime-root.mjs +11 -13
- package/runtime/engine/secrets.mjs +170 -102
- package/runtime/engine/sonar-config.mjs +16 -13
- package/runtime/engine/temp-root.mjs +3 -9
- package/runtime/knowledge/hfs/canon-pins.yaml +10 -10
- package/runtime/knowledge/hfs/rules.yaml +6 -6
- package/runtime/knowledge/hfs/slots.yaml +2 -2
- package/runtime/knowledge/sonar-gate.yaml +1 -1
- package/runtime/packages/hfs/templates/app/package-scripts/package.json +1 -1
- package/runtime/scripts/api/git/cat-file.mjs +0 -1
- package/runtime/scripts/api/git/config-get.mjs +1 -2
- package/runtime/scripts/api/git/diff.mjs +0 -1
- package/runtime/scripts/api/git/lib.mjs +32 -32
- package/runtime/scripts/api/git/ls-files.mjs +0 -1
- package/runtime/scripts/api/git/ls-tree.mjs +0 -1
- package/runtime/scripts/api/git/merge-base.mjs +2 -3
- package/runtime/scripts/api/git/remote.mjs +0 -1
- package/runtime/scripts/api/git/rev-parse-query.mjs +0 -1
- package/runtime/scripts/api/git/show.mjs +0 -1
- package/runtime/scripts/hfs/allows.mjs +37 -38
- package/runtime/scripts/hfs/architecture/ast-walks.mjs +180 -163
- package/runtime/scripts/hfs/architecture/automatic-gates.mjs +80 -73
- package/runtime/scripts/hfs/architecture/backend-app-files.mjs +88 -77
- package/runtime/scripts/hfs/architecture/backend.mjs +378 -357
- package/runtime/scripts/hfs/architecture/background-unowned.mjs +201 -187
- package/runtime/scripts/hfs/architecture/canon-clones.mjs +260 -209
- package/runtime/scripts/hfs/architecture/canon-jsx-clones.mjs +149 -116
- package/runtime/scripts/hfs/architecture/client-reaches-server.mjs +72 -68
- package/runtime/scripts/hfs/architecture/clones.mjs +212 -217
- package/runtime/scripts/hfs/architecture/config-unread.mjs +7 -9
- package/runtime/scripts/hfs/architecture/config.mjs +302 -268
- package/runtime/scripts/hfs/architecture/connection-map.mjs +258 -225
- package/runtime/scripts/hfs/architecture/constructor-deps.mjs +80 -71
- package/runtime/scripts/hfs/architecture/context-coupling.mjs +82 -77
- package/runtime/scripts/hfs/architecture/context-map.mjs +267 -234
- package/runtime/scripts/hfs/architecture/context-owner.mjs +73 -61
- package/runtime/scripts/hfs/architecture/context-platform-tables.mjs +47 -43
- package/runtime/scripts/hfs/architecture/context-transaction.mjs +54 -52
- package/runtime/scripts/hfs/architecture/contract-fixture-guard.mjs +113 -104
- package/runtime/scripts/hfs/architecture/contracts-readonly.mjs +288 -270
- package/runtime/scripts/hfs/architecture/contracts.mjs +408 -393
- package/runtime/scripts/hfs/architecture/cross-app-duplicate.mjs +50 -51
- package/runtime/scripts/hfs/architecture/dead-exports-bindings.mjs +143 -119
- package/runtime/scripts/hfs/architecture/dead-exports.mjs +286 -228
- package/runtime/scripts/hfs/architecture/default-deny.mjs +129 -110
- package/runtime/scripts/hfs/architecture/doc-language.mjs +24 -19
- package/runtime/scripts/hfs/architecture/entity-registry.mjs +20 -22
- package/runtime/scripts/hfs/architecture/entrypoint.mjs +47 -45
- package/runtime/scripts/hfs/architecture/error-codes.mjs +37 -35
- package/runtime/scripts/hfs/architecture/error-masked.mjs +55 -59
- package/runtime/scripts/hfs/architecture/fe-slot-allows.mjs +24 -23
- package/runtime/scripts/hfs/architecture/feature-shape.mjs +40 -38
- package/runtime/scripts/hfs/architecture/framework-pinned.mjs +21 -21
- package/runtime/scripts/hfs/architecture/frontend-block-render.mjs +106 -98
- package/runtime/scripts/hfs/architecture/frontend-grammar.mjs +153 -150
- package/runtime/scripts/hfs/architecture/frontend-routing.mjs +161 -149
- package/runtime/scripts/hfs/architecture/frontend-world-render.mjs +343 -305
- package/runtime/scripts/hfs/architecture/frontend-world.mjs +340 -294
- package/runtime/scripts/hfs/architecture/frontend.mjs +174 -184
- package/runtime/scripts/hfs/architecture/function-spec-providers.mjs +124 -106
- package/runtime/scripts/hfs/architecture/hfs-graph.mjs +52 -48
- package/runtime/scripts/hfs/architecture/hooks-are-hooks.mjs +81 -71
- package/runtime/scripts/hfs/architecture/i18n-keys.mjs +155 -141
- package/runtime/scripts/hfs/architecture/identity.mjs +141 -125
- package/runtime/scripts/hfs/architecture/index.mjs +272 -272
- package/runtime/scripts/hfs/architecture/injection-token-exported.mjs +45 -43
- package/runtime/scripts/hfs/architecture/jwt-ast.mjs +195 -176
- package/runtime/scripts/hfs/architecture/machine-ast.mjs +163 -155
- package/runtime/scripts/hfs/architecture/managed-scripts.mjs +19 -20
- package/runtime/scripts/hfs/architecture/module-per-transport.mjs +177 -172
- package/runtime/scripts/hfs/architecture/next-data-contract.mjs +100 -78
- package/runtime/scripts/hfs/architecture/next-data-inference.mjs +170 -154
- package/runtime/scripts/hfs/architecture/next-data-key.mjs +311 -275
- package/runtime/scripts/hfs/architecture/next-data-symbols.mjs +17 -17
- package/runtime/scripts/hfs/architecture/next-data.mjs +351 -334
- package/runtime/scripts/hfs/architecture/operation-contract-roots.mjs +39 -37
- package/runtime/scripts/hfs/architecture/owners.mjs +97 -98
- package/runtime/scripts/hfs/architecture/package-shape.mjs +56 -55
- package/runtime/scripts/hfs/architecture/presentation.mjs +138 -130
- package/runtime/scripts/hfs/architecture/reachability.mjs +258 -241
- package/runtime/scripts/hfs/architecture/register-once.mjs +152 -139
- package/runtime/scripts/hfs/architecture/registration.mjs +301 -267
- package/runtime/scripts/hfs/architecture/required-files.mjs +172 -167
- package/runtime/scripts/hfs/architecture/route-files-thin.mjs +85 -77
- package/runtime/scripts/hfs/architecture/schema-owner.mjs +206 -181
- package/runtime/scripts/hfs/architecture/server-action.mjs +48 -48
- package/runtime/scripts/hfs/architecture/side-boundary.mjs +2 -5
- package/runtime/scripts/hfs/architecture/source-names-shape.mjs +261 -259
- package/runtime/scripts/hfs/architecture/source-names.mjs +304 -278
- package/runtime/scripts/hfs/architecture/sql-keys.mjs +277 -194
- package/runtime/scripts/hfs/architecture/sql-owner.mjs +236 -194
- package/runtime/scripts/hfs/architecture/sql-returning.mjs +46 -45
- package/runtime/scripts/hfs/architecture/sql-token-forms.mjs +86 -74
- package/runtime/scripts/hfs/architecture/sql-tokens.mjs +456 -341
- package/runtime/scripts/hfs/architecture/staged-consumers.mjs +35 -30
- package/runtime/scripts/hfs/architecture/surface.mjs +64 -74
- package/runtime/scripts/hfs/architecture/symbols.mjs +209 -216
- package/runtime/scripts/hfs/architecture/test-world-files.mjs +165 -155
- package/runtime/scripts/hfs/architecture/tiers.mjs +161 -154
- package/runtime/scripts/hfs/architecture/transport-owner.mjs +155 -149
- package/runtime/scripts/hfs/architecture/type-context.mjs +255 -250
- package/runtime/scripts/hfs/architecture/typescript.mjs +358 -318
- package/runtime/scripts/hfs/architecture/unit-spec-providers.mjs +110 -92
- package/runtime/scripts/hfs/declaration-shape.mjs +140 -103
- package/runtime/scripts/hfs/declaration-slots.mjs +64 -61
- package/runtime/scripts/hfs/edition-slots.mjs +43 -40
- package/runtime/scripts/hfs/linear-text.mjs +20 -20
- package/runtime/scripts/hfs/param-names.mjs +6 -11
- package/runtime/scripts/hfs/path-findings.mjs +120 -100
- package/runtime/scripts/hfs/repo-identity.mjs +55 -42
- package/runtime/scripts/hfs/rule-catalog.mjs +353 -257
- package/runtime/scripts/hfs/rule-params-shape.mjs +60 -47
- package/runtime/scripts/hfs/rules/database-migrations.mjs +428 -388
- package/runtime/scripts/hfs/rules/fe-no-tests.mjs +37 -36
- package/runtime/scripts/hfs/rules/read.mjs +19 -15
- package/runtime/scripts/hfs/rules/secrets.mjs +1 -1
- package/runtime/scripts/hfs/rules/spec-placement.mjs +12 -13
- package/runtime/scripts/hfs/slot-app-view.mjs +69 -74
- package/runtime/scripts/hfs/slot-classify.mjs +42 -38
- package/runtime/scripts/hfs/slot-errors.mjs +8 -7
- package/runtime/scripts/hfs/slot-imports.mjs +70 -63
- package/runtime/scripts/hfs/slot-manifest-shape.mjs +74 -52
- package/runtime/scripts/hfs/slot-match.mjs +122 -111
- package/runtime/scripts/hfs/slot-path.mjs +0 -2
- package/runtime/scripts/hfs/slot-required.mjs +65 -59
- package/runtime/scripts/hfs/slot-semantic-problems.mjs +138 -112
- package/runtime/scripts/hfs/slot-side-problems.mjs +23 -19
- package/runtime/scripts/hfs/slots.mjs +175 -152
- package/runtime/scripts/hfs/test-world-slot.mjs +0 -1
- package/runtime/scripts/hfs/trailing-slashes.mjs +4 -4
- package/runtime/scripts/hfs/typescript-programs.mjs +66 -69
- package/runtime/scripts/hfs/view.mjs +38 -40
- package/runtime/scripts/lib/dockerfile.mjs +131 -114
- package/runtime/scripts/lib/env.mjs +3 -6
- package/runtime/scripts/lib/event-contract.mjs +73 -78
- package/runtime/scripts/lib/git.mjs +15 -16
- package/runtime/scripts/lib/glob.mjs +23 -14
- package/runtime/scripts/lib/grammar-lint.mjs +33 -37
- package/runtime/scripts/lib/i18n.mjs +32 -35
- package/runtime/scripts/lib/in-order.mjs +57 -38
- package/runtime/scripts/lib/json-clone.mjs +45 -36
- package/runtime/scripts/lib/json.mjs +26 -14
- package/runtime/scripts/lib/language.mjs +133 -129
- package/runtime/scripts/lib/list.mjs +9 -14
- package/runtime/scripts/lib/mutation-fence.mjs +10 -5
- package/runtime/scripts/lib/path-key.mjs +53 -38
- package/runtime/scripts/lib/read-text.mjs +30 -17
- package/runtime/scripts/lib/regex.mjs +1 -2
- package/runtime/scripts/lib/same-text.mjs +0 -1
- package/runtime/scripts/lib/sops-envelope.mjs +148 -120
- package/runtime/scripts/lib/stack-services.mjs +128 -129
- package/runtime/scripts/lib/ts-analysis.mjs +28 -26
- package/runtime/scripts/lib/ts-ast.mjs +36 -42
- package/runtime/scripts/lib/walk.mjs +33 -27
- package/runtime/scripts/lib/yaml-cached.mjs +4 -4
|
@@ -3,328 +3,366 @@ import { normalizedSymbolValue } from './ast-walks.mjs';
|
|
|
3
3
|
import { relativePath, unwrapExpression } from './typescript.mjs';
|
|
4
4
|
import { BlockRenderAnalysis } from './frontend-block-render.mjs';
|
|
5
5
|
function importDeclarationFor(ts, node) {
|
|
6
|
-
|
|
7
|
-
|
|
6
|
+
for (let current = node; current; current = current.parent)
|
|
7
|
+
if (ts.isImportDeclaration(current))
|
|
8
|
+
return current;
|
|
9
|
+
return null;
|
|
8
10
|
}
|
|
9
|
-
|
|
10
11
|
function isReactCreateElement(ts, checker, call) {
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
12
|
+
const expression = unwrapExpression(ts, call.expression);
|
|
13
|
+
if (ts.isIdentifier(expression)) {
|
|
14
|
+
const symbol = checker.getSymbolAtLocation(expression);
|
|
15
|
+
return (symbol?.declarations ?? []).some(declaration => {
|
|
16
|
+
const imported = ts.isImportSpecifier(declaration) ? declaration.propertyName?.text ?? declaration.name.text : null;
|
|
17
|
+
const parent = importDeclarationFor(ts, declaration);
|
|
18
|
+
return imported === 'createElement' && parent && ts.isStringLiteralLike(parent.moduleSpecifier) && parent.moduleSpecifier.text === 'react';
|
|
19
|
+
});
|
|
20
|
+
}
|
|
21
|
+
if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== 'createElement')
|
|
22
|
+
return false;
|
|
23
|
+
const symbol = checker.getSymbolAtLocation(expression.expression);
|
|
14
24
|
return (symbol?.declarations ?? []).some(declaration => {
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
25
|
+
const parent = importDeclarationFor(ts, declaration);
|
|
26
|
+
return (ts.isNamespaceImport(declaration) || ts.isImportClause(declaration))
|
|
27
|
+
&& parent && ts.isStringLiteralLike(parent.moduleSpecifier) && parent.moduleSpecifier.text === 'react';
|
|
18
28
|
});
|
|
19
|
-
}
|
|
20
|
-
if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== 'createElement') return false;
|
|
21
|
-
const symbol = checker.getSymbolAtLocation(expression.expression);
|
|
22
|
-
return (symbol?.declarations ?? []).some(declaration => {
|
|
23
|
-
const parent = importDeclarationFor(ts, declaration);
|
|
24
|
-
return (ts.isNamespaceImport(declaration) || ts.isImportClause(declaration))
|
|
25
|
-
&& parent && ts.isStringLiteralLike(parent.moduleSpecifier) && parent.moduleSpecifier.text === 'react';
|
|
26
|
-
});
|
|
27
29
|
}
|
|
28
|
-
|
|
29
30
|
function jsxTagName(ts, tagName) {
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
31
|
+
if (ts.isIdentifier(tagName))
|
|
32
|
+
return tagName.text;
|
|
33
|
+
if (ts.isPropertyAccessExpression(tagName))
|
|
34
|
+
return tagName.name.text;
|
|
35
|
+
return null;
|
|
33
36
|
}
|
|
34
|
-
|
|
35
37
|
function wrapperTag(ts, tagName) {
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
38
|
+
const name = jsxTagName(ts, tagName);
|
|
39
|
+
return name === 'Suspense' || name === 'SWRConfig' || name === 'Provider'
|
|
40
|
+
|| Boolean(name && (name.endsWith('Provider') || name.endsWith('ErrorBoundary')));
|
|
39
41
|
}
|
|
40
|
-
|
|
41
42
|
export class WorldRenderAnalysis {
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
43
|
+
world;
|
|
44
|
+
helpers;
|
|
45
|
+
blocks;
|
|
46
|
+
constructor(world, helpers) {
|
|
47
|
+
this.world = world;
|
|
48
|
+
this.helpers = helpers;
|
|
49
|
+
this.blocks = new BlockRenderAnalysis(this);
|
|
50
|
+
}
|
|
51
|
+
expressionHasRender(expression, checker, seen = new Set()) {
|
|
52
|
+
expression = unwrapExpression(this.world.ts, expression);
|
|
53
|
+
if (!expression)
|
|
54
|
+
return false;
|
|
55
|
+
if (this.world.ts.isJsxElement(expression) || this.world.ts.isJsxSelfClosingElement(expression) || this.world.ts.isJsxFragment(expression))
|
|
56
|
+
return true;
|
|
57
|
+
if (this.world.ts.isArrayLiteralExpression(expression))
|
|
58
|
+
return expression.elements.some(item => this.expressionHasRender(item, checker, seen));
|
|
59
|
+
if (this.world.ts.isCallExpression(expression) && isReactCreateElement(this.world.ts, checker, expression))
|
|
60
|
+
return true;
|
|
61
|
+
if (this.world.ts.isConditionalExpression(expression))
|
|
62
|
+
return this.conditionalExpressionHasRender(expression, checker, seen);
|
|
63
|
+
const logicalRender = this.logicalExpressionHasRender(expression, checker, seen);
|
|
64
|
+
if (logicalRender !== null)
|
|
65
|
+
return logicalRender;
|
|
66
|
+
if (this.world.ts.isCallExpression(expression)) {
|
|
67
|
+
const mapped = this.mappedExpressionHasRender(expression, checker, seen);
|
|
68
|
+
if (mapped !== null)
|
|
69
|
+
return mapped;
|
|
70
|
+
}
|
|
71
|
+
return this.referencedExpressionHasRender(expression, checker, seen);
|
|
72
|
+
}
|
|
73
|
+
conditionalExpressionHasRender(expression, checker, seen) {
|
|
74
|
+
return this.expressionHasRender(expression.whenTrue, checker, seen)
|
|
75
|
+
|| this.expressionHasRender(expression.whenFalse, checker, seen);
|
|
76
|
+
}
|
|
77
|
+
logicalExpressionHasRender(expression, checker, seen) {
|
|
78
|
+
const ts = this.world.ts;
|
|
79
|
+
if (!ts.isBinaryExpression(expression) || ![ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken,
|
|
80
|
+
ts.SyntaxKind.QuestionQuestionToken].includes(expression.operatorToken.kind))
|
|
81
|
+
return null;
|
|
82
|
+
return this.expressionHasRender(expression.left, checker, seen) || this.expressionHasRender(expression.right, checker, seen);
|
|
83
|
+
}
|
|
84
|
+
mappedExpressionHasRender(expression, checker, seen) {
|
|
85
|
+
const ts = this.world.ts;
|
|
86
|
+
if (!ts.isPropertyAccessExpression(expression.expression) && !ts.isElementAccessExpression(expression.expression))
|
|
87
|
+
return null;
|
|
88
|
+
let name = ts.isPropertyAccessExpression(expression.expression) ? expression.expression.name.text : null;
|
|
89
|
+
if (name === null && ts.isElementAccessExpression(expression.expression) && ts.isStringLiteralLike(expression.expression.argumentExpression))
|
|
90
|
+
name = expression.expression.argumentExpression.text;
|
|
91
|
+
if (name !== 'map' || !expression.arguments[0])
|
|
92
|
+
return null;
|
|
93
|
+
return this.world.expressionFunctions(expression.arguments[0], checker).some(fn => this.functionHasRender(fn, checker, seen));
|
|
94
|
+
}
|
|
95
|
+
referencedExpressionHasRender(expression, checker, seen) {
|
|
96
|
+
const ts = this.world.ts;
|
|
97
|
+
const selected = ts.isCallExpression(expression) ? expression.expression : expression;
|
|
98
|
+
const symbol = normalizedSymbolValue(ts, checker, this.helpers.selectedSymbol(ts, checker, selected));
|
|
99
|
+
if (!symbol || seen.has(symbol))
|
|
100
|
+
return false;
|
|
101
|
+
const nextSeen = new Set(seen).add(symbol);
|
|
102
|
+
if (ts.isIdentifier(expression) && this.identifierInitializerHasRender(symbol, checker, nextSeen))
|
|
103
|
+
return true;
|
|
104
|
+
if (ts.isCallExpression(expression))
|
|
105
|
+
return this.world.expressionFunctions(expression.expression, checker, seen)
|
|
106
|
+
.some(fn => this.functionHasRender(fn, checker, nextSeen));
|
|
107
|
+
return false;
|
|
108
|
+
}
|
|
109
|
+
identifierInitializerHasRender(symbol, checker, seen) {
|
|
110
|
+
for (const declaration of symbol.getDeclarations?.() ?? []) {
|
|
111
|
+
if (this.world.ts.isVariableDeclaration(declaration) && declaration.initializer
|
|
112
|
+
&& this.expressionHasRender(declaration.initializer, checker, seen))
|
|
113
|
+
return true;
|
|
114
|
+
}
|
|
115
|
+
return false;
|
|
116
|
+
}
|
|
117
|
+
functionHasRender(fn, checker, seen = new Set()) {
|
|
118
|
+
if (this.world.renderOutputCache.has(fn))
|
|
119
|
+
return this.world.renderOutputCache.get(fn);
|
|
120
|
+
this.world.renderOutputCache.set(fn, false);
|
|
121
|
+
const found = this.helpers.returnedExpressions(this.world.ts, fn).some(expression => this.expressionHasRender(expression, checker, seen));
|
|
122
|
+
this.world.renderOutputCache.set(fn, found);
|
|
123
|
+
return found;
|
|
124
|
+
}
|
|
125
|
+
capturesOuterFunction(fn, checker) {
|
|
126
|
+
const outers = [];
|
|
127
|
+
for (let parent = fn.parent; parent; parent = parent.parent)
|
|
128
|
+
if (this.world.ts.isFunctionLike(parent))
|
|
129
|
+
outers.push(parent);
|
|
130
|
+
if (!outers.length)
|
|
131
|
+
return false;
|
|
132
|
+
const capture = { found: false };
|
|
133
|
+
this.visitOuterReferences(fn.body ?? fn, fn, checker, outers, capture);
|
|
134
|
+
return capture.found;
|
|
135
|
+
}
|
|
136
|
+
visitOuterReferences(node, fn, checker, outers, capture) {
|
|
137
|
+
if (capture.found)
|
|
138
|
+
return;
|
|
139
|
+
if (this.referencesOuterFunction(node, fn, checker, outers)) {
|
|
140
|
+
capture.found = true;
|
|
141
|
+
return;
|
|
142
|
+
}
|
|
143
|
+
this.world.ts.forEachChild(node, child => this.visitOuterReferences(child, fn, checker, outers, capture));
|
|
144
|
+
}
|
|
145
|
+
referencesOuterFunction(node, fn, checker, outers) {
|
|
146
|
+
if (!this.world.ts.isIdentifier(node))
|
|
147
|
+
return false;
|
|
148
|
+
const symbol = checker.getSymbolAtLocation(node);
|
|
149
|
+
for (const declaration of symbol?.getDeclarations?.() ?? []) {
|
|
150
|
+
if (declaration.pos >= fn.pos && declaration.end <= fn.end)
|
|
151
|
+
continue;
|
|
152
|
+
if (outers.some(outer => declaration.pos >= outer.pos && declaration.end <= outer.end))
|
|
153
|
+
return true;
|
|
154
|
+
}
|
|
155
|
+
return false;
|
|
156
|
+
}
|
|
157
|
+
pureRenderTarget(expression, checker, expectedFile = null) {
|
|
158
|
+
const functions = this.world.expressionFunctions(expression, checker);
|
|
159
|
+
return functions.length > 0 && functions.every(fn => this.world.sourceSet.has(path.resolve(fn.getSourceFile().fileName))
|
|
160
|
+
&& (this.world.insideAny(this.world.roots.components, fn.getSourceFile().fileName) || this.world.insideAny(this.world.roots.features, fn.getSourceFile().fileName))
|
|
161
|
+
&& (!expectedFile || path.resolve(fn.getSourceFile().fileName) === expectedFile)
|
|
162
|
+
&& this.functionHasRender(fn, checker) && !this.world.functionUsesWorld(fn, checker) && !this.capturesOuterFunction(fn, checker));
|
|
163
|
+
}
|
|
164
|
+
expressionSuppliesRender(expression, checker) {
|
|
165
|
+
return this.expressionHasRender(expression, checker)
|
|
166
|
+
|| this.world.expressionFunctions(expression, checker).some(fn => this.functionHasRender(fn, checker));
|
|
167
|
+
}
|
|
168
|
+
isCreateElement(expression, checker) {
|
|
169
|
+
return isReactCreateElement(this.world.ts, checker, expression);
|
|
170
|
+
}
|
|
171
|
+
propValueBoundary(input, checker, seen, expectedFile, pureTarget) {
|
|
172
|
+
const ts = this.world.ts;
|
|
173
|
+
const value = unwrapExpression(ts, input);
|
|
174
|
+
if (pureTarget && this.blocks.renderProp(value, checker, expectedFile))
|
|
175
|
+
return true;
|
|
176
|
+
if (pureTarget && this.blocks.featureComposition(value, expectedFile) && ts.isObjectLiteralExpression(value)) {
|
|
177
|
+
return value.properties.every(property => !ts.isPropertyAssignment(property)
|
|
178
|
+
|| this.propValueBoundary(property.initializer, checker, seen, expectedFile, pureTarget));
|
|
179
|
+
}
|
|
180
|
+
return !this.expressionSuppliesRender(value, checker) || this.pureRenderTarget(value, checker, expectedFile)
|
|
181
|
+
|| this.renderBoundary(value, checker, seen, true, expectedFile);
|
|
182
|
+
}
|
|
183
|
+
routedLayoutChild(opening, child, checker) {
|
|
184
|
+
const ts = this.world.ts;
|
|
185
|
+
if (!ts.isJsxExpression(child) || !child.expression)
|
|
186
|
+
return false;
|
|
187
|
+
const source = opening.getSourceFile().fileName;
|
|
188
|
+
if (!/^apps\/[^/]+\/src\/features\/layouts\/[^/]+\/index\.tsx$/.test(relativePath(this.world.config.root, source)))
|
|
189
|
+
return false;
|
|
190
|
+
const sibling = path.resolve(path.dirname(source), 'component.tsx');
|
|
191
|
+
if (!this.pureRenderTarget(opening.tagName, checker, sibling))
|
|
192
|
+
return false;
|
|
193
|
+
const value = unwrapExpression(ts, child.expression);
|
|
194
|
+
if (!ts.isPropertyAccessExpression(value) || !['content', 'children'].includes(value.name.text))
|
|
195
|
+
return false;
|
|
196
|
+
const receiver = unwrapExpression(ts, value.expression);
|
|
197
|
+
if (!ts.isIdentifier(receiver))
|
|
198
|
+
return false;
|
|
199
|
+
const symbol = checker.getSymbolAtLocation(receiver);
|
|
200
|
+
return (symbol?.getDeclarations?.() ?? []).some(declaration => ts.isParameter(declaration));
|
|
201
|
+
}
|
|
202
|
+
renderBoundary(expression, checker, seen = new Set(), allowEmpty = false, expectedFile = null) {
|
|
203
|
+
const ts = this.world.ts;
|
|
204
|
+
expression = unwrapExpression(ts, expression);
|
|
205
|
+
if (!expression)
|
|
206
|
+
return allowEmpty;
|
|
207
|
+
if (expression.kind === ts.SyntaxKind.NullKeyword || expression.kind === ts.SyntaxKind.FalseKeyword)
|
|
208
|
+
return allowEmpty;
|
|
209
|
+
if (ts.isConditionalExpression(expression))
|
|
210
|
+
return this.conditionalRenderBoundary(expression, checker, seen, allowEmpty, expectedFile);
|
|
211
|
+
if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
|
|
212
|
+
return this.renderBoundary(expression.right, checker, seen, true, expectedFile);
|
|
213
|
+
}
|
|
214
|
+
if (ts.isArrayLiteralExpression(expression))
|
|
215
|
+
return this.arrayRenderBoundary(expression, checker, seen, allowEmpty, expectedFile);
|
|
216
|
+
if (ts.isIdentifier(expression))
|
|
217
|
+
return this.identifierRenderBoundary(expression, checker, seen, allowEmpty, expectedFile);
|
|
218
|
+
if (ts.isCallExpression(expression))
|
|
219
|
+
return this.callRenderBoundary(expression, checker, seen, expectedFile);
|
|
220
|
+
if (ts.isJsxFragment(expression))
|
|
221
|
+
return this.fragmentRenderBoundary(expression, checker, seen, expectedFile);
|
|
222
|
+
if (ts.isJsxElement(expression) || ts.isJsxSelfClosingElement(expression))
|
|
223
|
+
return this.jsxRenderBoundary(expression, checker, seen, expectedFile);
|
|
224
|
+
return false;
|
|
225
|
+
}
|
|
226
|
+
conditionalRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
|
|
227
|
+
return this.renderBoundary(expression.whenTrue, checker, seen, allowEmpty, expectedFile)
|
|
228
|
+
&& this.renderBoundary(expression.whenFalse, checker, seen, allowEmpty, expectedFile);
|
|
229
|
+
}
|
|
230
|
+
arrayRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
|
|
231
|
+
return expression.elements.length > 0
|
|
232
|
+
&& expression.elements.every(item => this.renderBoundary(item, checker, seen, allowEmpty, expectedFile));
|
|
233
|
+
}
|
|
234
|
+
identifierRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
|
|
235
|
+
const symbol = normalizedSymbolValue(this.world.ts, checker, checker.getSymbolAtLocation(expression));
|
|
236
|
+
if (!symbol || seen.has(symbol))
|
|
237
|
+
return false;
|
|
238
|
+
const nextSeen = new Set(seen).add(symbol);
|
|
239
|
+
const values = (symbol.getDeclarations?.() ?? []).flatMap(declaration => this.world.ts.isVariableDeclaration(declaration) && declaration.initializer
|
|
240
|
+
? [declaration.initializer] : []);
|
|
241
|
+
if (values.length)
|
|
242
|
+
return values.every(value => this.renderBoundary(value, checker, nextSeen, allowEmpty, expectedFile));
|
|
243
|
+
return false;
|
|
244
|
+
}
|
|
245
|
+
callRenderBoundary(expression, checker, seen, expectedFile) {
|
|
246
|
+
if (isReactCreateElement(this.world.ts, checker, expression))
|
|
247
|
+
return this.createElementBoundary(expression, checker, seen, expectedFile);
|
|
248
|
+
const mapped = this.mappedCallBoundary(expression, checker, seen, expectedFile);
|
|
249
|
+
if (mapped !== null)
|
|
250
|
+
return mapped;
|
|
251
|
+
return this.pureRenderTarget(expression.expression, checker, expectedFile);
|
|
252
|
+
}
|
|
253
|
+
createElementBoundary(expression, checker, seen, expectedFile) {
|
|
254
|
+
const ts = this.world.ts;
|
|
255
|
+
const target = expression.arguments[0] ? unwrapExpression(ts, expression.arguments[0]) : null;
|
|
256
|
+
if (!target || ts.isStringLiteralLike(target))
|
|
257
|
+
return false;
|
|
258
|
+
const pureTarget = this.pureRenderTarget(target, checker, expectedFile) && !wrapperTag(ts, target);
|
|
259
|
+
const wrapper = wrapperTag(ts, target);
|
|
260
|
+
if (!pureTarget && !wrapper)
|
|
261
|
+
return false;
|
|
262
|
+
const boundary = { hasBoundary: pureTarget };
|
|
263
|
+
const props = expression.arguments[1] ? unwrapExpression(ts, expression.arguments[1]) : null;
|
|
264
|
+
if (!this.createElementPropsBoundary(props, checker, seen, expectedFile, boundary, pureTarget))
|
|
265
|
+
return false;
|
|
266
|
+
const children = expression.arguments.slice(2);
|
|
267
|
+
if (children.length) {
|
|
268
|
+
if (!children.every(child => this.renderBoundary(child, checker, seen, false, expectedFile)))
|
|
269
|
+
return false;
|
|
270
|
+
boundary.hasBoundary = true;
|
|
271
|
+
}
|
|
272
|
+
return boundary.hasBoundary;
|
|
60
273
|
}
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
logicalExpressionHasRender(expression, checker, seen) {
|
|
70
|
-
const ts = this.world.ts;
|
|
71
|
-
if (!ts.isBinaryExpression(expression) || ![ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken,
|
|
72
|
-
ts.SyntaxKind.QuestionQuestionToken].includes(expression.operatorToken.kind)) return null;
|
|
73
|
-
return this.expressionHasRender(expression.left, checker, seen) || this.expressionHasRender(expression.right, checker, seen);
|
|
74
|
-
}
|
|
75
|
-
|
|
76
|
-
mappedExpressionHasRender(expression, checker, seen) {
|
|
77
|
-
const ts = this.world.ts;
|
|
78
|
-
if (!ts.isPropertyAccessExpression(expression.expression) && !ts.isElementAccessExpression(expression.expression)) return null;
|
|
79
|
-
let name = ts.isPropertyAccessExpression(expression.expression) ? expression.expression.name.text : null;
|
|
80
|
-
if (name === null && ts.isStringLiteralLike(expression.expression.argumentExpression)) name = expression.expression.argumentExpression.text;
|
|
81
|
-
if (name !== 'map' || !expression.arguments[0]) return null;
|
|
82
|
-
return this.world.expressionFunctions(expression.arguments[0], checker).some(fn => this.functionHasRender(fn, checker, seen));
|
|
83
|
-
}
|
|
84
|
-
|
|
85
|
-
referencedExpressionHasRender(expression, checker, seen) {
|
|
86
|
-
const ts = this.world.ts;
|
|
87
|
-
const selected = ts.isCallExpression(expression) ? expression.expression : expression;
|
|
88
|
-
const symbol = normalizedSymbolValue(ts, checker, this.helpers.selectedSymbol(ts, checker, selected));
|
|
89
|
-
if (!symbol || seen.has(symbol)) return false;
|
|
90
|
-
const nextSeen = new Set(seen).add(symbol);
|
|
91
|
-
if (ts.isIdentifier(expression) && this.identifierInitializerHasRender(symbol, checker, nextSeen)) return true;
|
|
92
|
-
if (ts.isCallExpression(expression)) return this.world.expressionFunctions(expression.expression, checker, seen)
|
|
93
|
-
.some(fn => this.functionHasRender(fn, checker, nextSeen));
|
|
94
|
-
return false;
|
|
95
|
-
}
|
|
96
|
-
|
|
97
|
-
identifierInitializerHasRender(symbol, checker, seen) {
|
|
98
|
-
for (const declaration of symbol.getDeclarations?.() ?? []) {
|
|
99
|
-
if (this.world.ts.isVariableDeclaration(declaration) && declaration.initializer
|
|
100
|
-
&& this.expressionHasRender(declaration.initializer, checker, seen)) return true;
|
|
274
|
+
createElementPropsBoundary(props, checker, seen, expectedFile, boundary, pureTarget) {
|
|
275
|
+
const ts = this.world.ts;
|
|
276
|
+
if (!props || props.kind === ts.SyntaxKind.NullKeyword)
|
|
277
|
+
return true;
|
|
278
|
+
if (!ts.isObjectLiteralExpression(props) || props.properties.some(property => ts.isSpreadAssignment(property)))
|
|
279
|
+
return false;
|
|
280
|
+
return props.properties.every(property => this.propsPropertyBoundary(property, checker, seen, expectedFile, boundary, pureTarget));
|
|
101
281
|
}
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
for (let parent = fn.parent; parent; parent = parent.parent) if (this.world.ts.isFunctionLike(parent)) outers.push(parent);
|
|
116
|
-
if (!outers.length) return false;
|
|
117
|
-
const capture = { found: false };
|
|
118
|
-
this.visitOuterReferences(fn.body ?? fn, fn, checker, outers, capture);
|
|
119
|
-
return capture.found;
|
|
120
|
-
}
|
|
121
|
-
|
|
122
|
-
visitOuterReferences(node, fn, checker, outers, capture) {
|
|
123
|
-
if (capture.found) return;
|
|
124
|
-
if (this.referencesOuterFunction(node, fn, checker, outers)) {
|
|
125
|
-
capture.found = true;
|
|
126
|
-
return;
|
|
282
|
+
propsPropertyBoundary(property, checker, seen, expectedFile, boundary, pureTarget) {
|
|
283
|
+
const ts = this.world.ts;
|
|
284
|
+
if (!ts.isPropertyAssignment(property))
|
|
285
|
+
return true;
|
|
286
|
+
const value = unwrapExpression(ts, property.initializer);
|
|
287
|
+
if (!this.propValueBoundary(value, checker, seen, expectedFile, pureTarget))
|
|
288
|
+
return false;
|
|
289
|
+
if (!this.expressionSuppliesRender(value, checker))
|
|
290
|
+
return true;
|
|
291
|
+
const name = property.name && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ? property.name.text : null;
|
|
292
|
+
if (name !== null && ['children', 'component', 'content', 'render', 'view'].includes(name))
|
|
293
|
+
boundary.hasBoundary = true;
|
|
294
|
+
return true;
|
|
127
295
|
}
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
296
|
+
mappedCallBoundary(expression, checker, seen, expectedFile) {
|
|
297
|
+
const ts = this.world.ts;
|
|
298
|
+
if (!ts.isPropertyAccessExpression(expression.expression) && !ts.isElementAccessExpression(expression.expression))
|
|
299
|
+
return null;
|
|
300
|
+
let name = ts.isPropertyAccessExpression(expression.expression) ? expression.expression.name.text : null;
|
|
301
|
+
if (name === null && ts.isElementAccessExpression(expression.expression) && ts.isStringLiteralLike(expression.expression.argumentExpression))
|
|
302
|
+
name = expression.expression.argumentExpression.text;
|
|
303
|
+
if (name !== 'map' || !expression.arguments[0])
|
|
304
|
+
return null;
|
|
305
|
+
const renderers = this.world.expressionFunctions(expression.arguments[0], checker);
|
|
306
|
+
return renderers.length > 0 && renderers.every(fn => !this.world.functionUsesWorld(fn, checker)
|
|
307
|
+
&& this.helpers.returnedExpressions(ts, fn).length > 0
|
|
308
|
+
&& this.helpers.returnedExpressions(ts, fn).every(value => this.renderBoundary(value, checker, seen, true, expectedFile)));
|
|
137
309
|
}
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
return functions.length > 0 && functions.every(fn => this.world.sourceSet.has(path.resolve(fn.getSourceFile().fileName))
|
|
144
|
-
&& (this.world.insideAny(this.world.roots.components, fn.getSourceFile().fileName) || this.world.insideAny(this.world.roots.features, fn.getSourceFile().fileName))
|
|
145
|
-
&& (!expectedFile || path.resolve(fn.getSourceFile().fileName) === expectedFile)
|
|
146
|
-
&& this.functionHasRender(fn, checker) && !this.world.functionUsesWorld(fn, checker) && !this.capturesOuterFunction(fn, checker));
|
|
147
|
-
}
|
|
148
|
-
|
|
149
|
-
expressionSuppliesRender(expression, checker) {
|
|
150
|
-
return this.expressionHasRender(expression, checker)
|
|
151
|
-
|| this.world.expressionFunctions(expression, checker).some(fn => this.functionHasRender(fn, checker));
|
|
152
|
-
}
|
|
153
|
-
|
|
154
|
-
isCreateElement(expression, checker) {
|
|
155
|
-
return isReactCreateElement(this.world.ts, checker, expression);
|
|
156
|
-
}
|
|
157
|
-
|
|
158
|
-
propValueBoundary(input, checker, seen, expectedFile, pureTarget) {
|
|
159
|
-
const ts = this.world.ts;
|
|
160
|
-
const value = unwrapExpression(ts, input);
|
|
161
|
-
if (pureTarget && this.blocks.renderProp(value, checker, expectedFile)) return true;
|
|
162
|
-
if (pureTarget && this.blocks.featureComposition(value, expectedFile) && ts.isObjectLiteralExpression(value)) {
|
|
163
|
-
return value.properties.every(property => !ts.isPropertyAssignment(property)
|
|
164
|
-
|| this.propValueBoundary(property.initializer, checker, seen, expectedFile, pureTarget));
|
|
310
|
+
fragmentRenderBoundary(expression, checker, seen, expectedFile) {
|
|
311
|
+
const ts = this.world.ts;
|
|
312
|
+
const children = expression.children.filter(child => !ts.isJsxText(child) || child.text.trim());
|
|
313
|
+
return children.length > 0 && children.every(child => !ts.isJsxText(child)
|
|
314
|
+
&& this.renderBoundary(ts.isJsxExpression(child) ? child.expression : child, checker, seen, false, expectedFile));
|
|
165
315
|
}
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
const receiver = unwrapExpression(ts, value.expression);
|
|
180
|
-
if (!ts.isIdentifier(receiver)) return false;
|
|
181
|
-
const symbol = checker.getSymbolAtLocation(receiver);
|
|
182
|
-
return (symbol?.getDeclarations?.() ?? []).some(declaration => ts.isParameter(declaration));
|
|
183
|
-
}
|
|
184
|
-
|
|
185
|
-
renderBoundary(expression, checker, seen = new Set(), allowEmpty = false, expectedFile = null) {
|
|
186
|
-
const ts = this.world.ts;
|
|
187
|
-
expression = unwrapExpression(ts, expression);
|
|
188
|
-
if (!expression) return allowEmpty;
|
|
189
|
-
if (expression.kind === ts.SyntaxKind.NullKeyword || expression.kind === ts.SyntaxKind.FalseKeyword) return allowEmpty;
|
|
190
|
-
if (ts.isConditionalExpression(expression)) return this.conditionalRenderBoundary(expression, checker, seen, allowEmpty, expectedFile);
|
|
191
|
-
if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
|
|
192
|
-
return this.renderBoundary(expression.right, checker, seen, true, expectedFile);
|
|
316
|
+
jsxRenderBoundary(expression, checker, seen, expectedFile) {
|
|
317
|
+
const ts = this.world.ts;
|
|
318
|
+
const opening = ts.isJsxElement(expression) ? expression.openingElement : expression;
|
|
319
|
+
const pureTarget = this.pureRenderTarget(opening.tagName, checker, expectedFile) && !wrapperTag(ts, opening.tagName);
|
|
320
|
+
const wrapper = wrapperTag(ts, opening.tagName);
|
|
321
|
+
if (!pureTarget && !wrapper)
|
|
322
|
+
return false;
|
|
323
|
+
const boundary = { hasBoundary: pureTarget };
|
|
324
|
+
if (!this.jsxChildrenBoundary(expression, opening, checker, seen, expectedFile, pureTarget, boundary))
|
|
325
|
+
return false;
|
|
326
|
+
if (!this.jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary, pureTarget))
|
|
327
|
+
return false;
|
|
328
|
+
return boundary.hasBoundary;
|
|
193
329
|
}
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
arrayRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
|
|
208
|
-
return expression.elements.length > 0
|
|
209
|
-
&& expression.elements.every(item => this.renderBoundary(item, checker, seen, allowEmpty, expectedFile));
|
|
210
|
-
}
|
|
211
|
-
|
|
212
|
-
identifierRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
|
|
213
|
-
const symbol = normalizedSymbolValue(this.world.ts, checker, checker.getSymbolAtLocation(expression));
|
|
214
|
-
if (!symbol || seen.has(symbol)) return false;
|
|
215
|
-
const nextSeen = new Set(seen).add(symbol);
|
|
216
|
-
const values = (symbol.getDeclarations?.() ?? []).flatMap(declaration => this.world.ts.isVariableDeclaration(declaration) && declaration.initializer
|
|
217
|
-
? [declaration.initializer] : []);
|
|
218
|
-
if (values.length) return values.every(value => this.renderBoundary(value, checker, nextSeen, allowEmpty, expectedFile));
|
|
219
|
-
return false;
|
|
220
|
-
}
|
|
221
|
-
|
|
222
|
-
callRenderBoundary(expression, checker, seen, expectedFile) {
|
|
223
|
-
if (isReactCreateElement(this.world.ts, checker, expression)) return this.createElementBoundary(expression, checker, seen, expectedFile);
|
|
224
|
-
const mapped = this.mappedCallBoundary(expression, checker, seen, expectedFile);
|
|
225
|
-
if (mapped !== null) return mapped;
|
|
226
|
-
return this.pureRenderTarget(expression.expression, checker, expectedFile);
|
|
227
|
-
}
|
|
228
|
-
|
|
229
|
-
createElementBoundary(expression, checker, seen, expectedFile) {
|
|
230
|
-
const ts = this.world.ts;
|
|
231
|
-
const target = expression.arguments[0] ? unwrapExpression(ts, expression.arguments[0]) : null;
|
|
232
|
-
if (!target || ts.isStringLiteralLike(target)) return false;
|
|
233
|
-
const pureTarget = this.pureRenderTarget(target, checker, expectedFile) && !wrapperTag(ts, target);
|
|
234
|
-
const wrapper = wrapperTag(ts, target);
|
|
235
|
-
if (!pureTarget && !wrapper) return false;
|
|
236
|
-
const boundary = { hasBoundary: pureTarget };
|
|
237
|
-
const props = expression.arguments[1] ? unwrapExpression(ts, expression.arguments[1]) : null;
|
|
238
|
-
if (!this.createElementPropsBoundary(props, checker, seen, expectedFile, boundary, pureTarget)) return false;
|
|
239
|
-
const children = expression.arguments.slice(2);
|
|
240
|
-
if (children.length) {
|
|
241
|
-
if (!children.every(child => this.renderBoundary(child, checker, seen, false, expectedFile))) return false;
|
|
242
|
-
boundary.hasBoundary = true;
|
|
330
|
+
jsxChildrenBoundary(expression, opening, checker, seen, expectedFile, pureTarget, boundary) {
|
|
331
|
+
const ts = this.world.ts;
|
|
332
|
+
const children = ts.isJsxElement(expression)
|
|
333
|
+
? expression.children.filter(child => !ts.isJsxText(child) || child.text.trim()) : [];
|
|
334
|
+
if (!children.length)
|
|
335
|
+
return true;
|
|
336
|
+
const routedChild = pureTarget && children.length === 1 && this.routedLayoutChild(opening, children[0], checker);
|
|
337
|
+
if (!routedChild && !children.every(child => !ts.isJsxText(child)
|
|
338
|
+
&& this.renderBoundary(ts.isJsxExpression(child) ? child.expression : child, checker, seen, false, expectedFile)))
|
|
339
|
+
return false;
|
|
340
|
+
boundary.hasBoundary = true;
|
|
341
|
+
return true;
|
|
243
342
|
}
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
const ts = this.world.ts;
|
|
249
|
-
if (!props || props.kind === ts.SyntaxKind.NullKeyword) return true;
|
|
250
|
-
if (!ts.isObjectLiteralExpression(props) || props.properties.some(property => ts.isSpreadAssignment(property))) return false;
|
|
251
|
-
return props.properties.every(property => this.propsPropertyBoundary(property, checker, seen, expectedFile, boundary, pureTarget));
|
|
252
|
-
}
|
|
253
|
-
|
|
254
|
-
propsPropertyBoundary(property, checker, seen, expectedFile, boundary, pureTarget) {
|
|
255
|
-
const ts = this.world.ts;
|
|
256
|
-
if (!ts.isPropertyAssignment(property)) return true;
|
|
257
|
-
const value = unwrapExpression(ts, property.initializer);
|
|
258
|
-
if (!this.propValueBoundary(value, checker, seen, expectedFile, pureTarget)) return false;
|
|
259
|
-
if (!this.expressionSuppliesRender(value, checker)) return true;
|
|
260
|
-
const name = property.name && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ? property.name.text : null;
|
|
261
|
-
if (['children', 'component', 'content', 'render', 'view'].includes(name)) boundary.hasBoundary = true;
|
|
262
|
-
return true;
|
|
263
|
-
}
|
|
264
|
-
|
|
265
|
-
mappedCallBoundary(expression, checker, seen, expectedFile) {
|
|
266
|
-
const ts = this.world.ts;
|
|
267
|
-
if (!ts.isPropertyAccessExpression(expression.expression) && !ts.isElementAccessExpression(expression.expression)) return null;
|
|
268
|
-
let name = ts.isPropertyAccessExpression(expression.expression) ? expression.expression.name.text : null;
|
|
269
|
-
if (name === null && ts.isStringLiteralLike(expression.expression.argumentExpression)) name = expression.expression.argumentExpression.text;
|
|
270
|
-
if (name !== 'map' || !expression.arguments[0]) return null;
|
|
271
|
-
const renderers = this.world.expressionFunctions(expression.arguments[0], checker);
|
|
272
|
-
return renderers.length > 0 && renderers.every(fn => !this.world.functionUsesWorld(fn, checker)
|
|
273
|
-
&& this.helpers.returnedExpressions(ts, fn).length > 0
|
|
274
|
-
&& this.helpers.returnedExpressions(ts, fn).every(value => this.renderBoundary(value, checker, seen, true, expectedFile)));
|
|
275
|
-
}
|
|
276
|
-
|
|
277
|
-
fragmentRenderBoundary(expression, checker, seen, expectedFile) {
|
|
278
|
-
const ts = this.world.ts;
|
|
279
|
-
const children = expression.children.filter(child => !ts.isJsxText(child) || child.text.trim());
|
|
280
|
-
return children.length > 0 && children.every(child => !ts.isJsxText(child)
|
|
281
|
-
&& this.renderBoundary(ts.isJsxExpression(child) ? child.expression : child, checker, seen, false, expectedFile));
|
|
282
|
-
}
|
|
283
|
-
|
|
284
|
-
jsxRenderBoundary(expression, checker, seen, expectedFile) {
|
|
285
|
-
const ts = this.world.ts;
|
|
286
|
-
const opening = ts.isJsxElement(expression) ? expression.openingElement : expression;
|
|
287
|
-
const pureTarget = this.pureRenderTarget(opening.tagName, checker, expectedFile) && !wrapperTag(ts, opening.tagName);
|
|
288
|
-
const wrapper = wrapperTag(ts, opening.tagName);
|
|
289
|
-
if (!pureTarget && !wrapper) return false;
|
|
290
|
-
const boundary = { hasBoundary: pureTarget };
|
|
291
|
-
if (!this.jsxChildrenBoundary(expression, opening, checker, seen, expectedFile, pureTarget, boundary)) return false;
|
|
292
|
-
if (!this.jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary, pureTarget)) return false;
|
|
293
|
-
return boundary.hasBoundary;
|
|
294
|
-
}
|
|
295
|
-
|
|
296
|
-
jsxChildrenBoundary(expression, opening, checker, seen, expectedFile, pureTarget, boundary) {
|
|
297
|
-
const ts = this.world.ts;
|
|
298
|
-
const children = ts.isJsxElement(expression)
|
|
299
|
-
? expression.children.filter(child => !ts.isJsxText(child) || child.text.trim()) : [];
|
|
300
|
-
if (!children.length) return true;
|
|
301
|
-
const routedChild = pureTarget && children.length === 1 && this.routedLayoutChild(opening, children[0], checker);
|
|
302
|
-
if (!routedChild && !children.every(child => !ts.isJsxText(child)
|
|
303
|
-
&& this.renderBoundary(ts.isJsxExpression(child) ? child.expression : child, checker, seen, false, expectedFile))) return false;
|
|
304
|
-
boundary.hasBoundary = true;
|
|
305
|
-
return true;
|
|
306
|
-
}
|
|
307
|
-
|
|
308
|
-
jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary, pureTarget = false) {
|
|
309
|
-
const ts = this.world.ts;
|
|
310
|
-
return opening.attributes.properties.every(attribute => !ts.isJsxAttribute(attribute) || !attribute.initializer
|
|
311
|
-
|| this.jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary, pureTarget));
|
|
312
|
-
}
|
|
313
|
-
|
|
314
|
-
jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary, pureTarget) {
|
|
315
|
-
const ts = this.world.ts;
|
|
316
|
-
const name = attribute.name.text;
|
|
317
|
-
if (['fallback', 'errorElement'].includes(name)) {
|
|
318
|
-
if (ts.isStringLiteral(attribute.initializer)) return false;
|
|
319
|
-
if (ts.isJsxExpression(attribute.initializer)
|
|
320
|
-
&& !this.renderBoundary(attribute.initializer.expression, checker, seen, true, expectedFile)) return false;
|
|
343
|
+
jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary, pureTarget = false) {
|
|
344
|
+
const ts = this.world.ts;
|
|
345
|
+
return opening.attributes.properties.every(attribute => !ts.isJsxAttribute(attribute) || !attribute.initializer
|
|
346
|
+
|| this.jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary, pureTarget));
|
|
321
347
|
}
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
348
|
+
jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary, pureTarget) {
|
|
349
|
+
const ts = this.world.ts;
|
|
350
|
+
const name = ts.isIdentifier(attribute.name) ? attribute.name.text : null;
|
|
351
|
+
if (name !== null && ['fallback', 'errorElement'].includes(name)) {
|
|
352
|
+
if (ts.isStringLiteral(attribute.initializer))
|
|
353
|
+
return false;
|
|
354
|
+
if (ts.isJsxExpression(attribute.initializer)
|
|
355
|
+
&& !this.renderBoundary(attribute.initializer.expression, checker, seen, true, expectedFile))
|
|
356
|
+
return false;
|
|
357
|
+
}
|
|
358
|
+
if (ts.isJsxExpression(attribute.initializer) && attribute.initializer.expression
|
|
359
|
+
&& !this.propValueBoundary(attribute.initializer.expression, checker, seen, expectedFile, pureTarget))
|
|
360
|
+
return false;
|
|
361
|
+
if (ts.isJsxExpression(attribute.initializer) && attribute.initializer.expression
|
|
362
|
+
&& this.expressionSuppliesRender(attribute.initializer.expression, checker)) {
|
|
363
|
+
if (name !== null && ['component', 'content', 'render', 'view'].includes(name))
|
|
364
|
+
boundary.hasBoundary = true;
|
|
365
|
+
}
|
|
366
|
+
return true;
|
|
327
367
|
}
|
|
328
|
-
return true;
|
|
329
|
-
}
|
|
330
368
|
}
|