@skathi-native/cli 0.1.0-beta.4 → 0.3.0
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/aot/host-globals.json +1 -1
- package/aot/pin.ts +1 -1
- package/aot/toolchain.lock.json +5 -5
- package/aot/transform.ts +9 -1
- package/aot-inputs.ts +21 -2
- package/build.ts +284 -64
- package/check/builtins.json +11 -11
- package/check/bundle.ts +265 -0
- package/check/codes.ts +46 -0
- package/check/css-catalog.json +451 -0
- package/check/css.ts +512 -0
- package/check/finding.ts +63 -1
- package/check/graph.ts +14 -1
- package/check/index.ts +30 -49
- package/check/program.ts +26 -6
- package/cli/aot-build.ts +2 -6
- package/cli/build-app.ts +19 -0
- package/cli/create.ts +70 -12
- package/cli/dev.ts +11 -6
- package/cli/effects.ts +39 -18
- package/cli/gallery.ts +106 -0
- package/cli/sk.ts +5 -2
- package/devtools/commands.ts +26 -1
- package/devtools/ctl.ts +4 -3
- package/effects/compile.ts +160 -31
- package/effects/sk.slang +359 -30
- package/gallery.json +1 -0
- package/package.json +9 -5
- package/prod.ts +78 -10
- package/svelte.ts +76 -0
- package/templates/icon.png +0 -0
- package/templates/showcase/assets/textures/golden.png +0 -0
- package/templates/showcase/assets/textures/hammered.png +0 -0
- package/templates/showcase/assets/textures/noir.png +0 -0
- package/templates/showcase/assets/textures/reeded.png +0 -0
- package/templates/showcase/assets/textures/teal-orange.png +0 -0
- package/templates/showcase/shaders/dissolve.slang +40 -0
- package/templates/showcase/shaders/fireflies.slang +58 -0
- package/templates/showcase/shaders/glass.slang +31 -0
- package/templates/showcase/shaders/grade.slang +34 -0
- package/templates/showcase/shaders/halftone.slang +42 -0
- package/templates/showcase/shaders/lens.slang +51 -0
- package/templates/showcase/shaders/nebula.slang +57 -0
- package/templates/showcase/shaders/orbit.slang +52 -0
- package/templates/showcase/shaders/pond.slang +76 -0
- package/templates/showcase/shaders/ripples.slang +71 -0
- package/templates/showcase/shaders/shatter.slang +116 -0
- package/templates/showcase/shaders/snow.slang +57 -0
- package/templates/showcase/shaders/spotlight.slang +52 -0
- package/templates/showcase/src/App.vue +11 -16
- package/templates/showcase/src/components/FullWindow.vue +77 -0
- package/templates/showcase/src/components/Page.vue +2 -0
- package/templates/showcase/src/fullwindow.ts +36 -0
- package/templates/showcase/src/icons.ts +2 -0
- package/templates/showcase/src/pages/GraphicsPage.vue +122 -0
- package/templates/showcase/src/pages/MotionPage.vue +71 -1
- package/templates/showcase/src/pages/ShadersPage.vue +443 -0
- package/templates/showcase/src/router.ts +32 -1
- package/templates/svelte/.vscode/settings.json +3 -0
- package/templates/svelte/assets/hello.txt +1 -0
- package/templates/svelte/src/App.svelte +142 -0
- package/templates/svelte/src/main.ts +4 -0
- package/vitecompat.ts +2 -0
package/check/bundle.ts
ADDED
|
@@ -0,0 +1,265 @@
|
|
|
1
|
+
// What of a source file runs in the production bundle. The bundler keeps code behind a guard it could have folded
|
|
2
|
+
// (`if (DEV)` with esm-env's `DEV` resolved to `false` in another module), so the bundle itself is read: a finding is
|
|
3
|
+
// dropped when the code it maps to sits under a guard that is constant there, or in a function all of whose
|
|
4
|
+
// references in the bundle do. The bundle holds compiled components too, so no caller is out of sight.
|
|
5
|
+
|
|
6
|
+
import { resolve } from "node:path";
|
|
7
|
+
import type ts from "typescript";
|
|
8
|
+
import type { Range } from "./schema";
|
|
9
|
+
import type { ModuleGraph } from "./graph";
|
|
10
|
+
import type { TypeScript } from "./program";
|
|
11
|
+
|
|
12
|
+
type Bundle = NonNullable<ModuleGraph["bundle"]>;
|
|
13
|
+
/** [original line, original column, generated line, generated column], zero-based. */
|
|
14
|
+
type Segment = [number, number, number, number];
|
|
15
|
+
|
|
16
|
+
const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
17
|
+
const MAX_DEPTH = 40;
|
|
18
|
+
|
|
19
|
+
function decode(bundle: Bundle, key: (path: string) => string): Map<string, Segment[]> {
|
|
20
|
+
const bySource = new Map<number, Segment[]>();
|
|
21
|
+
let source = 0;
|
|
22
|
+
let line = 0;
|
|
23
|
+
let column = 0;
|
|
24
|
+
const groups = bundle.mappings.split(";");
|
|
25
|
+
for (let genLine = 0; genLine < groups.length; genLine++) {
|
|
26
|
+
let genColumn = 0;
|
|
27
|
+
for (const segment of groups[genLine]!.split(",")) {
|
|
28
|
+
if (!segment) continue;
|
|
29
|
+
const fields: number[] = [];
|
|
30
|
+
for (let i = 0, shift = 0, value = 0; i < segment.length; i++) {
|
|
31
|
+
const digit = B64.indexOf(segment[i]!);
|
|
32
|
+
value += (digit & 31) << shift;
|
|
33
|
+
if (digit & 32) {
|
|
34
|
+
shift += 5;
|
|
35
|
+
continue;
|
|
36
|
+
}
|
|
37
|
+
fields.push(value & 1 ? -(value >>> 1) : value >>> 1);
|
|
38
|
+
shift = 0;
|
|
39
|
+
value = 0;
|
|
40
|
+
}
|
|
41
|
+
genColumn += fields[0] ?? 0;
|
|
42
|
+
if (fields.length < 4) continue;
|
|
43
|
+
source += fields[1]!;
|
|
44
|
+
line += fields[2]!;
|
|
45
|
+
column += fields[3]!;
|
|
46
|
+
const list = bySource.get(source) ?? [];
|
|
47
|
+
list.push([line, column, genLine, genColumn]);
|
|
48
|
+
bySource.set(source, list);
|
|
49
|
+
}
|
|
50
|
+
}
|
|
51
|
+
const out = new Map<string, Segment[]>();
|
|
52
|
+
for (const [index, list] of bySource) {
|
|
53
|
+
const path = bundle.sources[index];
|
|
54
|
+
if (!path) continue;
|
|
55
|
+
out.set(
|
|
56
|
+
key(path),
|
|
57
|
+
list.sort((a, b) => a[0] - b[0] || a[1] - b[1]),
|
|
58
|
+
);
|
|
59
|
+
}
|
|
60
|
+
return out;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
export class BundleLiveness {
|
|
64
|
+
private segments: Map<string, Segment[]> | null = null;
|
|
65
|
+
private file: ts.SourceFile | null = null;
|
|
66
|
+
private checker: ts.TypeChecker | null = null;
|
|
67
|
+
private byName: Map<string, ts.Identifier[]> | null = null;
|
|
68
|
+
private readonly functions = new Map<ts.Node, boolean>();
|
|
69
|
+
|
|
70
|
+
constructor(
|
|
71
|
+
private readonly t: TypeScript,
|
|
72
|
+
private readonly bundle: Bundle,
|
|
73
|
+
) {}
|
|
74
|
+
|
|
75
|
+
private key(path: string): string {
|
|
76
|
+
return this.t.sys.useCaseSensitiveFileNames ? resolve(path) : resolve(path).toLowerCase();
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
/** False when the code at `range` of `path` is in the bundle but cannot run there. */
|
|
80
|
+
live(path: string, range: Range): boolean {
|
|
81
|
+
this.segments ??= decode(this.bundle, (p) => this.key(p));
|
|
82
|
+
const segments = this.segments.get(this.key(path));
|
|
83
|
+
if (!segments) return true;
|
|
84
|
+
const at = this.generated(segments, range);
|
|
85
|
+
if (!at) return true;
|
|
86
|
+
this.parse();
|
|
87
|
+
const offset = this.file!.getPositionOfLineAndCharacter(at[0], at[1]);
|
|
88
|
+
return !this.dead(this.nodeAt(offset), 0);
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
private generated(segments: Segment[], range: Range): [number, number] | null {
|
|
92
|
+
const before = (s: Segment, line: number, character: number) => s[0] < line || (s[0] === line && s[1] < character);
|
|
93
|
+
let lo = 0;
|
|
94
|
+
let hi = segments.length;
|
|
95
|
+
while (lo < hi) {
|
|
96
|
+
const mid = (lo + hi) >> 1;
|
|
97
|
+
if (before(segments[mid]!, range.start.line, range.start.character)) lo = mid + 1;
|
|
98
|
+
else hi = mid;
|
|
99
|
+
}
|
|
100
|
+
const inside = segments[lo];
|
|
101
|
+
if (inside && before(inside, range.end.line, range.end.character + 1)) return [inside[2], inside[3]];
|
|
102
|
+
// A position the bundler mapped only at the start of its line.
|
|
103
|
+
const previous = segments[lo - 1];
|
|
104
|
+
return previous && previous[0] === range.start.line ? [previous[2], previous[3]] : null;
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
private parse(): void {
|
|
108
|
+
if (this.file) return;
|
|
109
|
+
const t = this.t;
|
|
110
|
+
const name = "/sk-check-bundle.js";
|
|
111
|
+
const file = t.createSourceFile(name, this.bundle.code, t.ScriptTarget.Latest, true, t.ScriptKind.JS);
|
|
112
|
+
const options: ts.CompilerOptions = { allowJs: true, noLib: true, noResolve: true, types: [] };
|
|
113
|
+
const host = t.createCompilerHost(options);
|
|
114
|
+
host.getSourceFile = (path) => (path === name ? file : undefined);
|
|
115
|
+
host.fileExists = (path) => path === name;
|
|
116
|
+
host.readFile = (path) => (path === name ? this.bundle.code : undefined);
|
|
117
|
+
this.checker = t.createProgram({ rootNames: [name], options, host }).getTypeChecker();
|
|
118
|
+
this.file = file;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
private nodeAt(offset: number): ts.Node {
|
|
122
|
+
let node: ts.Node = this.file!;
|
|
123
|
+
for (let found = true; found;) {
|
|
124
|
+
found = false;
|
|
125
|
+
this.t.forEachChild(node, (child) => {
|
|
126
|
+
if (found || offset < child.getStart(this.file!) || offset >= child.end) return;
|
|
127
|
+
node = child;
|
|
128
|
+
found = true;
|
|
129
|
+
});
|
|
130
|
+
}
|
|
131
|
+
return node;
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
private dead(node: ts.Node, depth: number): boolean {
|
|
135
|
+
const t = this.t;
|
|
136
|
+
for (let cur = node; cur.parent; cur = cur.parent) {
|
|
137
|
+
const p = cur.parent;
|
|
138
|
+
if (t.isIfStatement(p) && cur !== p.expression) {
|
|
139
|
+
const test = this.truth(p.expression, depth);
|
|
140
|
+
if (test === (cur === p.elseStatement)) return true;
|
|
141
|
+
} else if (t.isConditionalExpression(p) && cur !== p.condition) {
|
|
142
|
+
const test = this.truth(p.condition, depth);
|
|
143
|
+
if (test === (cur === p.whenFalse)) return true;
|
|
144
|
+
} else if (t.isBinaryExpression(p) && cur === p.right) {
|
|
145
|
+
const op = p.operatorToken.kind;
|
|
146
|
+
const left = this.truth(p.left, depth);
|
|
147
|
+
if (op === t.SyntaxKind.AmpersandAmpersandToken && left === false) return true;
|
|
148
|
+
if (op === t.SyntaxKind.BarBarToken && left === true) return true;
|
|
149
|
+
}
|
|
150
|
+
if (t.isFunctionDeclaration(cur) || t.isFunctionExpression(cur) || t.isArrowFunction(cur)) {
|
|
151
|
+
const verdict = this.uncalled(cur, depth);
|
|
152
|
+
if (verdict !== undefined) return verdict;
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
return false;
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
/** For a named function: whether every reference to it is dead; undefined when it has no name to follow. */
|
|
159
|
+
private uncalled(fn: ts.FunctionLikeDeclaration, depth: number): boolean | undefined {
|
|
160
|
+
const t = this.t;
|
|
161
|
+
const holder = t.isFunctionDeclaration(fn)
|
|
162
|
+
? fn.name
|
|
163
|
+
: t.isVariableDeclaration(fn.parent) && fn.parent.initializer === fn && t.isIdentifier(fn.parent.name)
|
|
164
|
+
? fn.parent.name
|
|
165
|
+
: undefined;
|
|
166
|
+
if (!holder) return undefined;
|
|
167
|
+
const known = this.functions.get(fn);
|
|
168
|
+
if (known !== undefined) return known;
|
|
169
|
+
if (depth > MAX_DEPTH) return false;
|
|
170
|
+
// While its callers are judged, a recursive call counts as live.
|
|
171
|
+
this.functions.set(fn, false);
|
|
172
|
+
const refs = this.references(holder);
|
|
173
|
+
const verdict = refs.length > 0 && refs.every((ref) => this.dead(ref, depth + 1));
|
|
174
|
+
this.functions.set(fn, verdict);
|
|
175
|
+
return verdict;
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
private references(name: ts.Identifier): ts.Identifier[] {
|
|
179
|
+
const t = this.t;
|
|
180
|
+
const checker = this.checker!;
|
|
181
|
+
if (!this.byName) {
|
|
182
|
+
this.byName = new Map();
|
|
183
|
+
const visit = (node: ts.Node): void => {
|
|
184
|
+
if (t.isIdentifier(node)) {
|
|
185
|
+
const list = this.byName!.get(node.text) ?? [];
|
|
186
|
+
list.push(node);
|
|
187
|
+
this.byName!.set(node.text, list);
|
|
188
|
+
}
|
|
189
|
+
t.forEachChild(node, visit);
|
|
190
|
+
};
|
|
191
|
+
visit(this.file!);
|
|
192
|
+
}
|
|
193
|
+
const symbolOf = (id: ts.Identifier) =>
|
|
194
|
+
t.isShorthandPropertyAssignment(id.parent)
|
|
195
|
+
? checker.getShorthandAssignmentValueSymbol(id.parent)
|
|
196
|
+
: checker.getSymbolAtLocation(id);
|
|
197
|
+
const symbol = symbolOf(name);
|
|
198
|
+
if (!symbol) return [];
|
|
199
|
+
return (this.byName.get(name.text) ?? []).filter((id) => id !== name && symbolOf(id) === symbol);
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
/** The truthiness of `expr` wherever it runs in the bundle, or undefined when it is not constant. */
|
|
203
|
+
private truth(expr: ts.Expression, depth: number): boolean | undefined {
|
|
204
|
+
const value = this.constant(expr, depth);
|
|
205
|
+
return value === NOT_CONSTANT ? undefined : !!value;
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
private constant(expr: ts.Expression, depth: number): unknown {
|
|
209
|
+
const t = this.t;
|
|
210
|
+
if (depth > MAX_DEPTH) return NOT_CONSTANT;
|
|
211
|
+
if (t.isParenthesizedExpression(expr)) return this.constant(expr.expression, depth);
|
|
212
|
+
if (expr.kind === t.SyntaxKind.TrueKeyword) return true;
|
|
213
|
+
if (expr.kind === t.SyntaxKind.FalseKeyword) return false;
|
|
214
|
+
if (expr.kind === t.SyntaxKind.NullKeyword) return null;
|
|
215
|
+
if (t.isNumericLiteral(expr)) return Number(expr.text);
|
|
216
|
+
if (t.isStringLiteral(expr) || t.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
|
|
217
|
+
if (t.isVoidExpression(expr)) return undefined;
|
|
218
|
+
if (t.isPrefixUnaryExpression(expr) && expr.operator === t.SyntaxKind.ExclamationToken) {
|
|
219
|
+
const value = this.constant(expr.operand, depth + 1);
|
|
220
|
+
return value === NOT_CONSTANT ? NOT_CONSTANT : !value;
|
|
221
|
+
}
|
|
222
|
+
if (t.isBinaryExpression(expr)) {
|
|
223
|
+
const op = expr.operatorToken.kind;
|
|
224
|
+
const left = this.constant(expr.left, depth + 1);
|
|
225
|
+
if (left === NOT_CONSTANT) return NOT_CONSTANT;
|
|
226
|
+
if (op === t.SyntaxKind.AmpersandAmpersandToken) return left ? this.constant(expr.right, depth + 1) : left;
|
|
227
|
+
if (op === t.SyntaxKind.BarBarToken) return left ? left : this.constant(expr.right, depth + 1);
|
|
228
|
+
const right = this.constant(expr.right, depth + 1);
|
|
229
|
+
if (right === NOT_CONSTANT) return NOT_CONSTANT;
|
|
230
|
+
if (op === t.SyntaxKind.EqualsEqualsEqualsToken) return left === right;
|
|
231
|
+
if (op === t.SyntaxKind.ExclamationEqualsEqualsToken) return left !== right;
|
|
232
|
+
if (op === t.SyntaxKind.EqualsEqualsToken) return left == right;
|
|
233
|
+
if (op === t.SyntaxKind.ExclamationEqualsToken) return left != right;
|
|
234
|
+
return NOT_CONSTANT;
|
|
235
|
+
}
|
|
236
|
+
if (t.isIdentifier(expr)) return this.binding(expr, depth);
|
|
237
|
+
return NOT_CONSTANT;
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
/** A variable initialised to a constant and never written again. */
|
|
241
|
+
private binding(id: ts.Identifier, depth: number): unknown {
|
|
242
|
+
const t = this.t;
|
|
243
|
+
const symbol = this.checker!.getSymbolAtLocation(id);
|
|
244
|
+
const declarations = symbol?.declarations ?? [];
|
|
245
|
+
const decl = declarations[0];
|
|
246
|
+
if (declarations.length !== 1 || !decl || !t.isVariableDeclaration(decl) || !decl.initializer) {
|
|
247
|
+
return NOT_CONSTANT;
|
|
248
|
+
}
|
|
249
|
+
if (!t.isIdentifier(decl.name)) return NOT_CONSTANT;
|
|
250
|
+
for (const ref of this.references(decl.name)) {
|
|
251
|
+
const p = ref.parent;
|
|
252
|
+
const written =
|
|
253
|
+
(t.isBinaryExpression(p) &&
|
|
254
|
+
p.left === ref &&
|
|
255
|
+
p.operatorToken.kind >= t.SyntaxKind.FirstAssignment &&
|
|
256
|
+
p.operatorToken.kind <= t.SyntaxKind.LastAssignment) ||
|
|
257
|
+
((t.isPrefixUnaryExpression(p) || t.isPostfixUnaryExpression(p)) &&
|
|
258
|
+
(p.operator === t.SyntaxKind.PlusPlusToken || p.operator === t.SyntaxKind.MinusMinusToken));
|
|
259
|
+
if (written) return NOT_CONSTANT;
|
|
260
|
+
}
|
|
261
|
+
return this.constant(decl.initializer, depth + 1);
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
const NOT_CONSTANT = Symbol("not constant");
|
package/check/codes.ts
CHANGED
|
@@ -16,6 +16,7 @@ export const RANGES = [
|
|
|
16
16
|
{ from: 1000, to: 1999, what: "breaks under AOT" },
|
|
17
17
|
{ from: 2000, to: 2999, what: "works under AOT, but slower" },
|
|
18
18
|
{ from: 3000, to: 3999, what: "typing quality: compiles, but AOT gets no type information" },
|
|
19
|
+
{ from: 4000, to: 4999, what: "CSS the native renderer does not apply" },
|
|
19
20
|
] as const;
|
|
20
21
|
|
|
21
22
|
const CODES: CodeInfo[] = [
|
|
@@ -184,6 +185,51 @@ const CODES: CodeInfo[] = [
|
|
|
184
185
|
example: 'declare module "some-package";',
|
|
185
186
|
fix: "Remove the shorthand declaration (or give it a body with real types), and convert the JavaScript file to TypeScript or annotate it with JSDoc.",
|
|
186
187
|
},
|
|
188
|
+
{
|
|
189
|
+
code: "SK4001",
|
|
190
|
+
severity: "warning",
|
|
191
|
+
title: "a CSS property Skathi does not support",
|
|
192
|
+
explanation:
|
|
193
|
+
"Skathi renders CSS natively, without a browser engine, and this property is not implemented: the declaration has no effect, and the app prints an advisory for it while it runs. Declarations inside `@supports` blocks, values from `var()` and CSS-wide keywords are not reported, nor is a value a browser would compute anyway (`float: none`).",
|
|
194
|
+
example: ".card {\n float: left;\n}",
|
|
195
|
+
fix: "Use what the help line suggests (flex or grid instead of `float`), or remove the declaration. Keep it for a browser build inside `@supports (float: left) { … }`.",
|
|
196
|
+
},
|
|
197
|
+
{
|
|
198
|
+
code: "SK4002",
|
|
199
|
+
severity: "warning",
|
|
200
|
+
title: "a CSS value Skathi does not apply",
|
|
201
|
+
explanation:
|
|
202
|
+
"The property is supported, but not with this value or function: for example the colour functions of `filter`, 3D functions of `transform`, or `width: fit-content`. The declaration is dropped and the app prints an advisory for it while it runs.",
|
|
203
|
+
example: ".avatar {\n filter: grayscale(1);\n}",
|
|
204
|
+
fix: "Use a value the help line names, or remove the declaration. Keep it for a browser build inside `@supports`.",
|
|
205
|
+
},
|
|
206
|
+
{
|
|
207
|
+
code: "SK4003",
|
|
208
|
+
severity: "warning",
|
|
209
|
+
title: "a CSS selector that never matches in Skathi",
|
|
210
|
+
explanation:
|
|
211
|
+
"The selector uses a pseudo-class or pseudo-element the engine cannot answer (`:visited`, `:placeholder-shown`, `::first-line`, `::-webkit-scrollbar`, a hover state inside `:not()`), so the whole rule is dropped.",
|
|
212
|
+
example: "input:placeholder-shown {\n opacity: 0.6;\n}",
|
|
213
|
+
fix: "Select on a class or data attribute the app sets from script, or use the property the help line names.",
|
|
214
|
+
},
|
|
215
|
+
{
|
|
216
|
+
code: "SK4004",
|
|
217
|
+
severity: "warning",
|
|
218
|
+
title: "a CSS at-rule Skathi does not support",
|
|
219
|
+
explanation:
|
|
220
|
+
"`@container`, `@layer` (outside Tailwind), `@scope`, `@starting-style`, `@counter-style`, `@font-feature-values` and `@namespace` are not implemented: the rules inside the block are dropped.",
|
|
221
|
+
example: "@container (min-width: 400px) {\n .card { display: grid; }\n}",
|
|
222
|
+
fix: "Move the rules out of the block, or use `@media` on the window size.",
|
|
223
|
+
},
|
|
224
|
+
{
|
|
225
|
+
code: "SK4005",
|
|
226
|
+
severity: "warning",
|
|
227
|
+
title: "a dependency's CSS uses what Skathi does not apply",
|
|
228
|
+
explanation:
|
|
229
|
+
"Stylesheets the app imports from this package use properties, values, selectors or at-rules the engine does not apply (the SK4001–SK4004 cases). One diagnostic per package; the places are listed as related locations.",
|
|
230
|
+
example: 'import "some-ui-kit/dist/style.css";',
|
|
231
|
+
fix: "Check that the package's components the app uses look right; allow SK4005 for the package once they do.",
|
|
232
|
+
},
|
|
187
233
|
];
|
|
188
234
|
|
|
189
235
|
export const REGISTRY: ReadonlyMap<string, CodeInfo> = new Map(CODES.map((c) => [c.code, c]));
|