aktion-runtime 0.5.6 → 0.5.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -1
- package/dist/aktion.iife.js +33 -33
- package/dist/aktion.iife.js.map +1 -1
- package/dist/aktion.js +23005 -22882
- package/dist/aktion.js.map +1 -1
- package/dist/aktion.umd.cjs +33 -33
- package/dist/aktion.umd.cjs.map +1 -1
- package/dist/testing.js +987 -10
- package/dist/testing.js.map +1 -1
- package/dist/types/element.d.ts +43 -0
- package/package.json +1 -1
package/dist/testing.js
CHANGED
|
@@ -2188,6 +2188,839 @@ function isCompiledProgram(value) {
|
|
|
2188
2188
|
const candidate = value;
|
|
2189
2189
|
return candidate.__aktionCompiled === COMPILED_PROGRAM_VERSION && typeof candidate.source === "string" && typeof candidate.path === "string" && !!candidate.program && Array.isArray(candidate.program.statements);
|
|
2190
2190
|
}
|
|
2191
|
+
function defineCompiledProgram(compiled) {
|
|
2192
|
+
return compiled;
|
|
2193
|
+
}
|
|
2194
|
+
const INDENT = " ";
|
|
2195
|
+
const SAFE_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
|
|
2196
|
+
const NEEDS_DOUBLE_QUOTE = /[\\"]/;
|
|
2197
|
+
function printProgram(program) {
|
|
2198
|
+
const lines = [];
|
|
2199
|
+
let prev = null;
|
|
2200
|
+
for (const stmt of program.statements) {
|
|
2201
|
+
if (prev && needsBlankLineBetween(prev, stmt)) lines.push("");
|
|
2202
|
+
lines.push(printStatement(stmt, 0));
|
|
2203
|
+
prev = stmt;
|
|
2204
|
+
}
|
|
2205
|
+
return lines.join("\n") + "\n";
|
|
2206
|
+
}
|
|
2207
|
+
function needsBlankLineBetween(prev, next) {
|
|
2208
|
+
const heavy = /* @__PURE__ */ new Set([
|
|
2209
|
+
"ComponentDeclaration",
|
|
2210
|
+
"EffectDeclaration",
|
|
2211
|
+
"ActionDeclaration",
|
|
2212
|
+
"HookDeclaration"
|
|
2213
|
+
]);
|
|
2214
|
+
if (heavy.has(prev.kind) || heavy.has(next.kind)) return true;
|
|
2215
|
+
return false;
|
|
2216
|
+
}
|
|
2217
|
+
function printStatement(stmt, indent) {
|
|
2218
|
+
const pad = INDENT.repeat(indent);
|
|
2219
|
+
const exp = "exported" in stmt && stmt.exported ? "export " : "";
|
|
2220
|
+
switch (stmt.kind) {
|
|
2221
|
+
case "Import": {
|
|
2222
|
+
const specs = stmt.specifiers.map((s) => {
|
|
2223
|
+
const imported = s.isState ? `$${s.imported}` : s.imported;
|
|
2224
|
+
if (s.local === s.imported) return imported;
|
|
2225
|
+
const local2 = s.isState ? `$${s.local}` : s.local;
|
|
2226
|
+
return `${imported} as ${local2}`;
|
|
2227
|
+
}).join(", ");
|
|
2228
|
+
return `${pad}import { ${specs} } from "${stmt.source}"`;
|
|
2229
|
+
}
|
|
2230
|
+
case "Assignment": {
|
|
2231
|
+
const lhs = stmt.isState ? `$${stmt.identifier}` : stmt.identifier;
|
|
2232
|
+
const expr = printExpression(stmt.expression, indent);
|
|
2233
|
+
return `${pad}${exp}${lhs} = ${expr}`;
|
|
2234
|
+
}
|
|
2235
|
+
case "ComponentDeclaration": {
|
|
2236
|
+
const params = stmt.params.map(printDeclParam).join(", ");
|
|
2237
|
+
const head = `${pad}${exp}function ${stmt.name}(${params}) {`;
|
|
2238
|
+
const body = printBlock(stmt.body.body, indent + 1);
|
|
2239
|
+
return body.length > 0 ? `${head}
|
|
2240
|
+
${body}
|
|
2241
|
+
${pad}}` : `${head}
|
|
2242
|
+
${pad}}`;
|
|
2243
|
+
}
|
|
2244
|
+
case "EffectDeclaration": {
|
|
2245
|
+
const deps = stmt.triggers.map(printTrigger).filter((s) => s.length > 0);
|
|
2246
|
+
if (stmt.rateLimit) {
|
|
2247
|
+
deps.push(`"${stmt.rateLimit.kind}(${stmt.rateLimit.ms})"`);
|
|
2248
|
+
}
|
|
2249
|
+
const body = printBlock(stmt.body.body, indent + 1);
|
|
2250
|
+
const depsArray = `[${deps.join(", ")}]`;
|
|
2251
|
+
return `${pad}$effect(() => {
|
|
2252
|
+
${body}
|
|
2253
|
+
${pad}}, ${depsArray})`;
|
|
2254
|
+
}
|
|
2255
|
+
case "ActionDeclaration": {
|
|
2256
|
+
const params = stmt.params.map(printDeclParam).join(", ");
|
|
2257
|
+
const head = `${pad}${exp}function ${stmt.name}(${params}) {`;
|
|
2258
|
+
const body = printBlock(stmt.body.body, indent + 1);
|
|
2259
|
+
return `${head}
|
|
2260
|
+
${body}
|
|
2261
|
+
${pad}}`;
|
|
2262
|
+
}
|
|
2263
|
+
case "HookDeclaration": {
|
|
2264
|
+
const params = stmt.params.map(printDeclParam).join(", ");
|
|
2265
|
+
const head = `${pad}${exp}function $${stmt.name}(${params}) {`;
|
|
2266
|
+
const body = printBlock(stmt.body.body, indent + 1);
|
|
2267
|
+
return `${head}
|
|
2268
|
+
${body}
|
|
2269
|
+
${pad}}`;
|
|
2270
|
+
}
|
|
2271
|
+
case "Await": {
|
|
2272
|
+
return `${pad}await ${printExpression(stmt.argument, indent)}`;
|
|
2273
|
+
}
|
|
2274
|
+
case "Return": {
|
|
2275
|
+
return stmt.argument ? `${pad}return ${printExpression(stmt.argument, indent)}` : `${pad}return`;
|
|
2276
|
+
}
|
|
2277
|
+
case "ExpressionStatement": {
|
|
2278
|
+
return `${pad}${printExpression(stmt.expression, indent)}`;
|
|
2279
|
+
}
|
|
2280
|
+
case "IfStatement": {
|
|
2281
|
+
const test = printExpression(stmt.test, indent);
|
|
2282
|
+
const cons = `{
|
|
2283
|
+
${printBlock(stmt.consequent.body, indent + 1)}
|
|
2284
|
+
${pad}}`;
|
|
2285
|
+
if (!stmt.alternate) return `${pad}if (${test}) ${cons}`;
|
|
2286
|
+
const alt = stmt.alternate.kind === "IfStatement" ? printStatement(stmt.alternate, indent).trimStart() : `{
|
|
2287
|
+
${printBlock(stmt.alternate.body, indent + 1)}
|
|
2288
|
+
${pad}}`;
|
|
2289
|
+
return `${pad}if (${test}) ${cons} else ${alt}`;
|
|
2290
|
+
}
|
|
2291
|
+
case "SwitchStatement": {
|
|
2292
|
+
const disc = printExpression(stmt.discriminant, indent);
|
|
2293
|
+
const cases = stmt.cases.map((c) => printSwitchCase(c, indent + 1)).join("\n");
|
|
2294
|
+
return `${pad}switch (${disc}) {
|
|
2295
|
+
${cases}
|
|
2296
|
+
${pad}}`;
|
|
2297
|
+
}
|
|
2298
|
+
case "ForOfStatement": {
|
|
2299
|
+
const iter = printExpression(stmt.iterable, indent);
|
|
2300
|
+
const body = `{
|
|
2301
|
+
${printBlock(stmt.body.body, indent + 1)}
|
|
2302
|
+
${pad}}`;
|
|
2303
|
+
return `${pad}for (let ${stmt.item} of ${iter}) ${body}`;
|
|
2304
|
+
}
|
|
2305
|
+
case "ForClassicStatement": {
|
|
2306
|
+
const init = stmt.init ? printStatement(stmt.init, 0).trimStart() : "";
|
|
2307
|
+
const test = stmt.test ? printExpression(stmt.test, indent) : "";
|
|
2308
|
+
const update = stmt.update ? printExpression(stmt.update, indent) : "";
|
|
2309
|
+
const body = `{
|
|
2310
|
+
${printBlock(stmt.body.body, indent + 1)}
|
|
2311
|
+
${pad}}`;
|
|
2312
|
+
return `${pad}for (${init}; ${test}; ${update}) ${body}`;
|
|
2313
|
+
}
|
|
2314
|
+
case "WhileStatement": {
|
|
2315
|
+
const test = printExpression(stmt.test, indent);
|
|
2316
|
+
const body = `{
|
|
2317
|
+
${printBlock(stmt.body.body, indent + 1)}
|
|
2318
|
+
${pad}}`;
|
|
2319
|
+
return `${pad}while (${test}) ${body}`;
|
|
2320
|
+
}
|
|
2321
|
+
case "DoWhileStatement": {
|
|
2322
|
+
const test = printExpression(stmt.test, indent);
|
|
2323
|
+
const body = `{
|
|
2324
|
+
${printBlock(stmt.body.body, indent + 1)}
|
|
2325
|
+
${pad}}`;
|
|
2326
|
+
return `${pad}do ${body} while (${test})`;
|
|
2327
|
+
}
|
|
2328
|
+
case "ForInStatement": {
|
|
2329
|
+
const iter = printExpression(stmt.iterable, indent);
|
|
2330
|
+
const body = `{
|
|
2331
|
+
${printBlock(stmt.body.body, indent + 1)}
|
|
2332
|
+
${pad}}`;
|
|
2333
|
+
return `${pad}for (let ${stmt.item} in ${iter}) ${body}`;
|
|
2334
|
+
}
|
|
2335
|
+
case "DestructureStatement": {
|
|
2336
|
+
const open = stmt.patternKind === "array" ? "[" : "{";
|
|
2337
|
+
const close = stmt.patternKind === "array" ? "]" : "}";
|
|
2338
|
+
const parts = stmt.bindings.map((b) => {
|
|
2339
|
+
const lead = b.rest ? "..." : "";
|
|
2340
|
+
const keyed = b.sourceKey ? `${b.sourceKey}: ${b.name}` : b.name || "";
|
|
2341
|
+
const def = b.defaultValue ? ` = ${printExpression(b.defaultValue, indent)}` : "";
|
|
2342
|
+
return `${lead}${keyed}${def}`;
|
|
2343
|
+
});
|
|
2344
|
+
const expr = printExpression(stmt.expression, indent);
|
|
2345
|
+
return `${pad}let ${open}${parts.join(", ")}${close} = ${expr}`;
|
|
2346
|
+
}
|
|
2347
|
+
case "BreakStatement":
|
|
2348
|
+
return `${pad}break`;
|
|
2349
|
+
case "ContinueStatement":
|
|
2350
|
+
return `${pad}continue`;
|
|
2351
|
+
case "ThrowStatement":
|
|
2352
|
+
return `${pad}throw ${printExpression(stmt.argument, indent)}`;
|
|
2353
|
+
case "TryStatement": {
|
|
2354
|
+
const block = `{
|
|
2355
|
+
${printBlock(stmt.block.body, indent + 1)}
|
|
2356
|
+
${pad}}`;
|
|
2357
|
+
let out = `${pad}try ${block}`;
|
|
2358
|
+
if (stmt.catchBlock) {
|
|
2359
|
+
const catchHead = stmt.catchParam ? ` (${stmt.catchParam})` : "";
|
|
2360
|
+
const catchBody = `{
|
|
2361
|
+
${printBlock(stmt.catchBlock.body, indent + 1)}
|
|
2362
|
+
${pad}}`;
|
|
2363
|
+
out += ` catch${catchHead} ${catchBody}`;
|
|
2364
|
+
}
|
|
2365
|
+
if (stmt.finallyBlock) {
|
|
2366
|
+
const finBody = `{
|
|
2367
|
+
${printBlock(stmt.finallyBlock.body, indent + 1)}
|
|
2368
|
+
${pad}}`;
|
|
2369
|
+
out += ` finally ${finBody}`;
|
|
2370
|
+
}
|
|
2371
|
+
return out;
|
|
2372
|
+
}
|
|
2373
|
+
}
|
|
2374
|
+
}
|
|
2375
|
+
function printDeclParam(p) {
|
|
2376
|
+
if (p.defaultValue) {
|
|
2377
|
+
return `${p.name} = ${printExpression(p.defaultValue, 0)}`;
|
|
2378
|
+
}
|
|
2379
|
+
return p.name;
|
|
2380
|
+
}
|
|
2381
|
+
function printTrigger(t) {
|
|
2382
|
+
if (t.kind === "lifecycle") return `"${t.name}"`;
|
|
2383
|
+
if (t.kind === "every") return `"every(${t.intervalMs})"`;
|
|
2384
|
+
if (t.kind === "state") return `$${t.name}`;
|
|
2385
|
+
return "";
|
|
2386
|
+
}
|
|
2387
|
+
function printBlock(stmts, indent) {
|
|
2388
|
+
return stmts.map((s) => printStatement(s, indent)).join("\n");
|
|
2389
|
+
}
|
|
2390
|
+
function printExpression(expr, indent) {
|
|
2391
|
+
switch (expr.kind) {
|
|
2392
|
+
case "Literal":
|
|
2393
|
+
return printLiteral(expr.value);
|
|
2394
|
+
case "Identifier":
|
|
2395
|
+
return expr.name;
|
|
2396
|
+
case "StateRef":
|
|
2397
|
+
return `$${expr.name}`;
|
|
2398
|
+
case "Array": {
|
|
2399
|
+
if (expr.elements.length === 0) return "[]";
|
|
2400
|
+
const items = expr.elements.map((e) => printExpression(e, indent));
|
|
2401
|
+
const inline = `[${items.join(", ")}]`;
|
|
2402
|
+
if (inline.length <= 80 && !items.some((s) => s.includes("\n"))) return inline;
|
|
2403
|
+
const pad = INDENT.repeat(indent + 1);
|
|
2404
|
+
return `[
|
|
2405
|
+
${items.map((s) => `${pad}${s}`).join(",\n")}
|
|
2406
|
+
${INDENT.repeat(indent)}]`;
|
|
2407
|
+
}
|
|
2408
|
+
case "Object": {
|
|
2409
|
+
if (expr.properties.length === 0) return "{}";
|
|
2410
|
+
const items = expr.properties.map((p) => printObjectProp(p, indent));
|
|
2411
|
+
const inline = `{ ${items.join(", ")} }`;
|
|
2412
|
+
if (inline.length <= 80 && !items.some((s) => s.includes("\n"))) return inline;
|
|
2413
|
+
const pad = INDENT.repeat(indent + 1);
|
|
2414
|
+
return `{
|
|
2415
|
+
${items.map((s) => `${pad}${s}`).join(",\n")}
|
|
2416
|
+
${INDENT.repeat(indent)}}`;
|
|
2417
|
+
}
|
|
2418
|
+
case "Member": {
|
|
2419
|
+
const obj = printExpression(expr.object, indent);
|
|
2420
|
+
const dot = expr.optional ? "?." : ".";
|
|
2421
|
+
if (expr.property) return `${obj}${dot}${expr.property}`;
|
|
2422
|
+
if (expr.computed) {
|
|
2423
|
+
const inner = printExpression(expr.computed, indent);
|
|
2424
|
+
return expr.optional ? `${obj}?.[${inner}]` : `${obj}[${inner}]`;
|
|
2425
|
+
}
|
|
2426
|
+
return obj;
|
|
2427
|
+
}
|
|
2428
|
+
case "Unary":
|
|
2429
|
+
return `${expr.operator}${printExpression(expr.argument, indent)}`;
|
|
2430
|
+
case "Binary":
|
|
2431
|
+
return `${printExpression(expr.left, indent)} ${expr.operator} ${printExpression(expr.right, indent)}`;
|
|
2432
|
+
case "Ternary":
|
|
2433
|
+
return `${printExpression(expr.test, indent)} ? ${printExpression(expr.consequent, indent)} : ${printExpression(expr.alternate, indent)}`;
|
|
2434
|
+
case "Call":
|
|
2435
|
+
return printCall(expr.callee, expr.arguments, indent);
|
|
2436
|
+
case "MethodCall": {
|
|
2437
|
+
const target = printExpression(expr.object, indent);
|
|
2438
|
+
const sep = expr.optional ? "?." : ".";
|
|
2439
|
+
return printCall(`${target}${sep}${expr.method}`, expr.arguments, indent);
|
|
2440
|
+
}
|
|
2441
|
+
case "Invoke": {
|
|
2442
|
+
const callee = printExpression(expr.callee, indent);
|
|
2443
|
+
const sep = expr.optional ? "?." : "";
|
|
2444
|
+
return printCall(`${callee}${sep}`, expr.arguments, indent);
|
|
2445
|
+
}
|
|
2446
|
+
case "New": {
|
|
2447
|
+
const callee = printExpression(expr.callee, indent);
|
|
2448
|
+
return `new ${printCall(callee, expr.arguments, indent)}`;
|
|
2449
|
+
}
|
|
2450
|
+
case "BuiltinCall":
|
|
2451
|
+
return printCall(`@${expr.name}`, expr.arguments, indent);
|
|
2452
|
+
case "Template":
|
|
2453
|
+
return printTemplate(expr.quasis, expr.expressions, indent);
|
|
2454
|
+
case "Spread":
|
|
2455
|
+
return `...${printExpression(expr.argument, indent)}`;
|
|
2456
|
+
case "Lambda": {
|
|
2457
|
+
const params = expr.params.map((p) => {
|
|
2458
|
+
const prefix = p.rest ? "..." : "";
|
|
2459
|
+
return p.defaultValue ? `${prefix}${p.name} = ${printExpression(p.defaultValue, indent)}` : `${prefix}${p.name}`;
|
|
2460
|
+
}).join(", ");
|
|
2461
|
+
const head = expr.params.length === 1 && !expr.params[0].defaultValue && !expr.params[0].rest ? expr.params[0].name : `(${params})`;
|
|
2462
|
+
return `${head} => ${printExpression(expr.body, indent)}`;
|
|
2463
|
+
}
|
|
2464
|
+
case "Block":
|
|
2465
|
+
return `{
|
|
2466
|
+
${printBlock(expr.body, indent + 1)}
|
|
2467
|
+
${INDENT.repeat(indent)}}`;
|
|
2468
|
+
}
|
|
2469
|
+
}
|
|
2470
|
+
function printCall(callee, args, indent) {
|
|
2471
|
+
if (args.length === 0) return `${callee}()`;
|
|
2472
|
+
const parts = args.map((a) => printExpression(a, indent));
|
|
2473
|
+
const inline = `${callee}(${parts.join(", ")})`;
|
|
2474
|
+
if (inline.length <= 80 && !parts.some((s) => s.includes("\n"))) return inline;
|
|
2475
|
+
const pad = INDENT.repeat(indent + 1);
|
|
2476
|
+
return `${callee}(
|
|
2477
|
+
${parts.map((s) => `${pad}${s}`).join(",\n")}
|
|
2478
|
+
${INDENT.repeat(indent)})`;
|
|
2479
|
+
}
|
|
2480
|
+
function printSwitchCase(c, indent) {
|
|
2481
|
+
const pad = INDENT.repeat(indent);
|
|
2482
|
+
const body = c.body.map((s) => printStatement(s, indent + 1)).join("\n");
|
|
2483
|
+
if (c.test === null) {
|
|
2484
|
+
return `${pad}default:
|
|
2485
|
+
${body}
|
|
2486
|
+
${printStatement({ kind: "ExpressionStatement", expression: { kind: "Identifier", name: "break" } }, indent + 1)}`;
|
|
2487
|
+
}
|
|
2488
|
+
return `${pad}case ${printExpression(c.test, indent)}:
|
|
2489
|
+
${body}
|
|
2490
|
+
${INDENT.repeat(indent + 1)}break`;
|
|
2491
|
+
}
|
|
2492
|
+
function printObjectProp(prop, indent) {
|
|
2493
|
+
if (prop.spread) return `...${printExpression(prop.value, indent)}`;
|
|
2494
|
+
const value = printExpression(prop.value, indent);
|
|
2495
|
+
if (prop.value.kind === "Identifier" && prop.value.name === prop.key && SAFE_IDENT.test(prop.key)) {
|
|
2496
|
+
return prop.key;
|
|
2497
|
+
}
|
|
2498
|
+
const key = SAFE_IDENT.test(prop.key) ? prop.key : printStringLiteral(prop.key);
|
|
2499
|
+
return `${key}: ${value}`;
|
|
2500
|
+
}
|
|
2501
|
+
function printLiteral(value) {
|
|
2502
|
+
if (value === null) return "null";
|
|
2503
|
+
if (typeof value === "string") return printStringLiteral(value);
|
|
2504
|
+
if (typeof value === "boolean") return value ? "true" : "false";
|
|
2505
|
+
return String(value);
|
|
2506
|
+
}
|
|
2507
|
+
function printStringLiteral(value) {
|
|
2508
|
+
if (NEEDS_DOUBLE_QUOTE.test(value)) {
|
|
2509
|
+
const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
|
|
2510
|
+
return `"${escaped}"`;
|
|
2511
|
+
}
|
|
2512
|
+
return `"${value}"`;
|
|
2513
|
+
}
|
|
2514
|
+
function printTemplate(quasis, expressions, indent) {
|
|
2515
|
+
const parts = [];
|
|
2516
|
+
for (let i = 0; i < quasis.length; i += 1) {
|
|
2517
|
+
parts.push(quasis[i] ?? "");
|
|
2518
|
+
if (i < expressions.length) {
|
|
2519
|
+
parts.push("${");
|
|
2520
|
+
parts.push(printExpression(expressions[i], indent));
|
|
2521
|
+
parts.push("}");
|
|
2522
|
+
}
|
|
2523
|
+
}
|
|
2524
|
+
return `\`${parts.join("")}\``;
|
|
2525
|
+
}
|
|
2526
|
+
function linkProgram(entrySource, entryPath, resolver) {
|
|
2527
|
+
const modules = /* @__PURE__ */ new Map();
|
|
2528
|
+
const order = [];
|
|
2529
|
+
const visiting = /* @__PURE__ */ new Set();
|
|
2530
|
+
const diagnostics = [];
|
|
2531
|
+
let nextId = 0;
|
|
2532
|
+
const fail = (path, line, column, message) => {
|
|
2533
|
+
diagnostics.push({
|
|
2534
|
+
line,
|
|
2535
|
+
column,
|
|
2536
|
+
message: path === entryPath ? message : `${path}: ${message}`,
|
|
2537
|
+
severity: "error"
|
|
2538
|
+
});
|
|
2539
|
+
};
|
|
2540
|
+
function load(path, sourceOverride) {
|
|
2541
|
+
const existing = modules.get(path);
|
|
2542
|
+
if (existing) return existing;
|
|
2543
|
+
if (visiting.has(path)) return void 0;
|
|
2544
|
+
visiting.add(path);
|
|
2545
|
+
let src;
|
|
2546
|
+
if (sourceOverride !== null) {
|
|
2547
|
+
src = sourceOverride;
|
|
2548
|
+
} else {
|
|
2549
|
+
try {
|
|
2550
|
+
src = resolver.load(path);
|
|
2551
|
+
} catch {
|
|
2552
|
+
visiting.delete(path);
|
|
2553
|
+
fail(entryPath, 0, 0, `Failed to load imported module "${path}".`);
|
|
2554
|
+
return void 0;
|
|
2555
|
+
}
|
|
2556
|
+
}
|
|
2557
|
+
const program = parse(src);
|
|
2558
|
+
const rec = {
|
|
2559
|
+
id: nextId++,
|
|
2560
|
+
path,
|
|
2561
|
+
program,
|
|
2562
|
+
edges: [],
|
|
2563
|
+
declaredPlain: /* @__PURE__ */ new Set(),
|
|
2564
|
+
declaredState: /* @__PURE__ */ new Set(),
|
|
2565
|
+
exportedPlain: /* @__PURE__ */ new Set(),
|
|
2566
|
+
exportedState: /* @__PURE__ */ new Set(),
|
|
2567
|
+
renamePlain: /* @__PURE__ */ new Map(),
|
|
2568
|
+
renameState: /* @__PURE__ */ new Map()
|
|
2569
|
+
};
|
|
2570
|
+
modules.set(path, rec);
|
|
2571
|
+
buildSymbolTable(rec);
|
|
2572
|
+
for (const stmt of program.statements) {
|
|
2573
|
+
if (stmt.kind !== "Import") continue;
|
|
2574
|
+
const resolved = resolver.resolve(stmt.source, path);
|
|
2575
|
+
rec.edges.push({ stmt, resolvedPath: resolved });
|
|
2576
|
+
if (resolved === null) {
|
|
2577
|
+
fail(path, stmt.loc?.line ?? 0, stmt.loc?.column ?? 0, `Cannot resolve import "${stmt.source}".`);
|
|
2578
|
+
continue;
|
|
2579
|
+
}
|
|
2580
|
+
load(resolved, null);
|
|
2581
|
+
}
|
|
2582
|
+
visiting.delete(path);
|
|
2583
|
+
order.push(path);
|
|
2584
|
+
return rec;
|
|
2585
|
+
}
|
|
2586
|
+
load(entryPath, entrySource);
|
|
2587
|
+
for (const rec of modules.values()) {
|
|
2588
|
+
if (rec.path === entryPath) continue;
|
|
2589
|
+
for (const name of rec.declaredPlain) rec.renamePlain.set(name, `__a${rec.id}_${name}`);
|
|
2590
|
+
for (const name of rec.declaredState) rec.renameState.set(name, `__a${rec.id}_${name}`);
|
|
2591
|
+
}
|
|
2592
|
+
for (const rec of modules.values()) {
|
|
2593
|
+
for (const { stmt, resolvedPath } of rec.edges) {
|
|
2594
|
+
if (resolvedPath === null) continue;
|
|
2595
|
+
const src = modules.get(resolvedPath);
|
|
2596
|
+
if (!src) continue;
|
|
2597
|
+
for (const spec of stmt.specifiers) {
|
|
2598
|
+
const line = stmt.loc?.line ?? 0;
|
|
2599
|
+
const column = stmt.loc?.column ?? 0;
|
|
2600
|
+
if (spec.isState) {
|
|
2601
|
+
if (!src.exportedState.has(spec.imported)) {
|
|
2602
|
+
fail(rec.path, line, column, `"${stmt.source}" does not export \`$${spec.imported}\`.`);
|
|
2603
|
+
continue;
|
|
2604
|
+
}
|
|
2605
|
+
rec.renameState.set(spec.local, src.renameState.get(spec.imported) ?? `__a${src.id}_${spec.imported}`);
|
|
2606
|
+
} else {
|
|
2607
|
+
if (!src.exportedPlain.has(spec.imported)) {
|
|
2608
|
+
fail(rec.path, line, column, `"${stmt.source}" does not export \`${spec.imported}\`.`);
|
|
2609
|
+
continue;
|
|
2610
|
+
}
|
|
2611
|
+
rec.renamePlain.set(spec.local, src.renamePlain.get(spec.imported) ?? `__a${src.id}_${spec.imported}`);
|
|
2612
|
+
}
|
|
2613
|
+
}
|
|
2614
|
+
}
|
|
2615
|
+
}
|
|
2616
|
+
const merged = [];
|
|
2617
|
+
for (const path of order) {
|
|
2618
|
+
const rec = modules.get(path);
|
|
2619
|
+
const renamer = makeRenamer(rec);
|
|
2620
|
+
for (const stmt of rec.program.statements) {
|
|
2621
|
+
if (stmt.kind === "Import") continue;
|
|
2622
|
+
renamer.renameTopLevel(stmt);
|
|
2623
|
+
stripExported(stmt);
|
|
2624
|
+
if (stmt.kind === "EffectDeclaration" && rec.path !== entryPath) {
|
|
2625
|
+
stmt.name = `__effect_a${rec.id}_${stmt.name.replace(/^__effect_/, "")}`;
|
|
2626
|
+
}
|
|
2627
|
+
merged.push(stmt);
|
|
2628
|
+
}
|
|
2629
|
+
}
|
|
2630
|
+
const entryRec = modules.get(entryPath);
|
|
2631
|
+
return {
|
|
2632
|
+
program: { statements: merged, errors: entryRec ? entryRec.program.errors : [] },
|
|
2633
|
+
diagnostics,
|
|
2634
|
+
dependencies: order.filter((p) => p !== entryPath)
|
|
2635
|
+
};
|
|
2636
|
+
}
|
|
2637
|
+
function buildSymbolTable(rec) {
|
|
2638
|
+
for (const stmt of rec.program.statements) {
|
|
2639
|
+
switch (stmt.kind) {
|
|
2640
|
+
case "Assignment":
|
|
2641
|
+
if (stmt.isState) {
|
|
2642
|
+
rec.declaredState.add(stmt.identifier);
|
|
2643
|
+
if (stmt.exported) rec.exportedState.add(stmt.identifier);
|
|
2644
|
+
} else {
|
|
2645
|
+
rec.declaredPlain.add(stmt.identifier);
|
|
2646
|
+
if (stmt.exported) rec.exportedPlain.add(stmt.identifier);
|
|
2647
|
+
}
|
|
2648
|
+
break;
|
|
2649
|
+
case "ComponentDeclaration":
|
|
2650
|
+
case "ActionDeclaration":
|
|
2651
|
+
rec.declaredPlain.add(stmt.name);
|
|
2652
|
+
if (stmt.exported) rec.exportedPlain.add(stmt.name);
|
|
2653
|
+
break;
|
|
2654
|
+
case "HookDeclaration":
|
|
2655
|
+
rec.declaredState.add(stmt.name);
|
|
2656
|
+
if (stmt.exported) rec.exportedState.add(stmt.name);
|
|
2657
|
+
break;
|
|
2658
|
+
case "DestructureStatement":
|
|
2659
|
+
for (const b of stmt.bindings) if (b.name) rec.declaredPlain.add(b.name);
|
|
2660
|
+
break;
|
|
2661
|
+
}
|
|
2662
|
+
}
|
|
2663
|
+
}
|
|
2664
|
+
function stripExported(stmt) {
|
|
2665
|
+
if (stmt.kind === "Assignment" || stmt.kind === "ComponentDeclaration" || stmt.kind === "ActionDeclaration" || stmt.kind === "HookDeclaration") {
|
|
2666
|
+
delete stmt.exported;
|
|
2667
|
+
}
|
|
2668
|
+
}
|
|
2669
|
+
function makeRenamer(rec) {
|
|
2670
|
+
const shadow = [];
|
|
2671
|
+
const shadowed = (name) => {
|
|
2672
|
+
for (const set of shadow) if (set.has(name)) return true;
|
|
2673
|
+
return false;
|
|
2674
|
+
};
|
|
2675
|
+
const rPlain = (name) => shadowed(name) ? name : rec.renamePlain.get(name) ?? name;
|
|
2676
|
+
const rState = (name) => rec.renameState.get(name) ?? name;
|
|
2677
|
+
const push = (names) => {
|
|
2678
|
+
shadow.push(new Set(names));
|
|
2679
|
+
};
|
|
2680
|
+
const pop = () => {
|
|
2681
|
+
shadow.pop();
|
|
2682
|
+
};
|
|
2683
|
+
const patternNames = (p) => p.bindings.map((b) => b.name).filter((n) => !!n);
|
|
2684
|
+
const paramNames = (params) => {
|
|
2685
|
+
const out = [];
|
|
2686
|
+
for (const p of params) {
|
|
2687
|
+
if (p.name) out.push(p.name);
|
|
2688
|
+
if (p.pattern) out.push(...patternNames(p.pattern));
|
|
2689
|
+
}
|
|
2690
|
+
return out;
|
|
2691
|
+
};
|
|
2692
|
+
const renameParamDefaults = (params) => {
|
|
2693
|
+
for (const p of params) if (p.defaultValue) renameExpr(p.defaultValue);
|
|
2694
|
+
};
|
|
2695
|
+
function renameExpr(expr) {
|
|
2696
|
+
switch (expr.kind) {
|
|
2697
|
+
case "Literal":
|
|
2698
|
+
return;
|
|
2699
|
+
case "Identifier":
|
|
2700
|
+
expr.name = rPlain(expr.name);
|
|
2701
|
+
return;
|
|
2702
|
+
case "StateRef":
|
|
2703
|
+
expr.name = rState(expr.name);
|
|
2704
|
+
return;
|
|
2705
|
+
case "Array":
|
|
2706
|
+
for (const el2 of expr.elements) renameExpr(el2);
|
|
2707
|
+
return;
|
|
2708
|
+
case "Object":
|
|
2709
|
+
for (const prop of expr.properties) {
|
|
2710
|
+
if (prop.computedKey) renameExpr(prop.computedKey);
|
|
2711
|
+
renameExpr(prop.value);
|
|
2712
|
+
}
|
|
2713
|
+
return;
|
|
2714
|
+
case "Member":
|
|
2715
|
+
renameExpr(expr.object);
|
|
2716
|
+
if (expr.computed) renameExpr(expr.computed);
|
|
2717
|
+
return;
|
|
2718
|
+
case "Unary":
|
|
2719
|
+
renameExpr(expr.argument);
|
|
2720
|
+
return;
|
|
2721
|
+
case "Binary":
|
|
2722
|
+
renameExpr(expr.left);
|
|
2723
|
+
renameExpr(expr.right);
|
|
2724
|
+
return;
|
|
2725
|
+
case "Ternary":
|
|
2726
|
+
renameExpr(expr.test);
|
|
2727
|
+
renameExpr(expr.consequent);
|
|
2728
|
+
renameExpr(expr.alternate);
|
|
2729
|
+
return;
|
|
2730
|
+
case "Call":
|
|
2731
|
+
expr.callee = rPlain(expr.callee);
|
|
2732
|
+
for (const a of expr.arguments) renameExpr(a);
|
|
2733
|
+
return;
|
|
2734
|
+
case "MethodCall":
|
|
2735
|
+
renameExpr(expr.object);
|
|
2736
|
+
for (const a of expr.arguments) renameExpr(a);
|
|
2737
|
+
return;
|
|
2738
|
+
case "Invoke":
|
|
2739
|
+
renameExpr(expr.callee);
|
|
2740
|
+
for (const a of expr.arguments) renameExpr(a);
|
|
2741
|
+
return;
|
|
2742
|
+
case "BuiltinCall":
|
|
2743
|
+
for (const a of expr.arguments) renameExpr(a);
|
|
2744
|
+
return;
|
|
2745
|
+
case "New":
|
|
2746
|
+
renameExpr(expr.callee);
|
|
2747
|
+
for (const a of expr.arguments) renameExpr(a);
|
|
2748
|
+
return;
|
|
2749
|
+
case "Template":
|
|
2750
|
+
for (const e of expr.expressions) renameExpr(e);
|
|
2751
|
+
return;
|
|
2752
|
+
case "Spread":
|
|
2753
|
+
renameExpr(expr.argument);
|
|
2754
|
+
return;
|
|
2755
|
+
case "Lambda":
|
|
2756
|
+
push(paramNames(expr.params));
|
|
2757
|
+
renameParamDefaults(expr.params);
|
|
2758
|
+
renameExpr(expr.body);
|
|
2759
|
+
pop();
|
|
2760
|
+
return;
|
|
2761
|
+
case "Block":
|
|
2762
|
+
renameBlock(expr);
|
|
2763
|
+
return;
|
|
2764
|
+
}
|
|
2765
|
+
}
|
|
2766
|
+
function renameBlock(block) {
|
|
2767
|
+
push([]);
|
|
2768
|
+
const scope = shadow[shadow.length - 1];
|
|
2769
|
+
for (const stmt of block.body) {
|
|
2770
|
+
renameStatement(stmt, false);
|
|
2771
|
+
addBlockLocals(stmt, scope);
|
|
2772
|
+
}
|
|
2773
|
+
pop();
|
|
2774
|
+
}
|
|
2775
|
+
function addBlockLocals(stmt, scope) {
|
|
2776
|
+
if (stmt.kind === "DestructureStatement") {
|
|
2777
|
+
for (const b of stmt.bindings) if (b.name) scope.add(b.name);
|
|
2778
|
+
} else if (stmt.kind === "ComponentDeclaration" || stmt.kind === "ActionDeclaration") {
|
|
2779
|
+
scope.add(stmt.name);
|
|
2780
|
+
}
|
|
2781
|
+
}
|
|
2782
|
+
function renameTopLevel(stmt) {
|
|
2783
|
+
if (stmt.kind === "DestructureStatement") {
|
|
2784
|
+
renameExpr(stmt.expression);
|
|
2785
|
+
for (const b of stmt.bindings) {
|
|
2786
|
+
if (b.defaultValue) renameExpr(b.defaultValue);
|
|
2787
|
+
b.name = rPlain(b.name);
|
|
2788
|
+
}
|
|
2789
|
+
return;
|
|
2790
|
+
}
|
|
2791
|
+
renameStatement(stmt, true);
|
|
2792
|
+
}
|
|
2793
|
+
function renameStatement(stmt, topLevel) {
|
|
2794
|
+
switch (stmt.kind) {
|
|
2795
|
+
case "Import":
|
|
2796
|
+
return;
|
|
2797
|
+
case "Assignment":
|
|
2798
|
+
stmt.identifier = stmt.isState ? rState(stmt.identifier) : rPlain(stmt.identifier);
|
|
2799
|
+
renameExpr(stmt.expression);
|
|
2800
|
+
return;
|
|
2801
|
+
case "ComponentDeclaration":
|
|
2802
|
+
case "ActionDeclaration":
|
|
2803
|
+
stmt.name = rPlain(stmt.name);
|
|
2804
|
+
push(paramNames(stmt.params));
|
|
2805
|
+
renameParamDefaults(stmt.params);
|
|
2806
|
+
renameBlock(stmt.body);
|
|
2807
|
+
pop();
|
|
2808
|
+
return;
|
|
2809
|
+
case "HookDeclaration":
|
|
2810
|
+
stmt.name = rState(stmt.name);
|
|
2811
|
+
push(paramNames(stmt.params));
|
|
2812
|
+
renameParamDefaults(stmt.params);
|
|
2813
|
+
renameBlock(stmt.body);
|
|
2814
|
+
pop();
|
|
2815
|
+
return;
|
|
2816
|
+
case "EffectDeclaration":
|
|
2817
|
+
for (const t of stmt.triggers) if (t.kind === "state") t.name = rState(t.name);
|
|
2818
|
+
renameBlock(stmt.body);
|
|
2819
|
+
return;
|
|
2820
|
+
case "Await":
|
|
2821
|
+
renameExpr(stmt.argument);
|
|
2822
|
+
return;
|
|
2823
|
+
case "Return":
|
|
2824
|
+
if (stmt.argument) renameExpr(stmt.argument);
|
|
2825
|
+
return;
|
|
2826
|
+
case "ExpressionStatement":
|
|
2827
|
+
renameExpr(stmt.expression);
|
|
2828
|
+
return;
|
|
2829
|
+
case "IfStatement":
|
|
2830
|
+
renameExpr(stmt.test);
|
|
2831
|
+
renameBlock(stmt.consequent);
|
|
2832
|
+
if (stmt.alternate) {
|
|
2833
|
+
if (stmt.alternate.kind === "IfStatement") renameStatement(stmt.alternate, false);
|
|
2834
|
+
else renameBlock(stmt.alternate);
|
|
2835
|
+
}
|
|
2836
|
+
return;
|
|
2837
|
+
case "SwitchStatement":
|
|
2838
|
+
renameExpr(stmt.discriminant);
|
|
2839
|
+
for (const c of stmt.cases) {
|
|
2840
|
+
if (c.test) renameExpr(c.test);
|
|
2841
|
+
for (const s of c.body) renameStatement(s, false);
|
|
2842
|
+
}
|
|
2843
|
+
return;
|
|
2844
|
+
case "ForOfStatement": {
|
|
2845
|
+
renameExpr(stmt.iterable);
|
|
2846
|
+
const names = [stmt.item];
|
|
2847
|
+
if (stmt.index) names.push(stmt.index);
|
|
2848
|
+
if (stmt.destructure) names.push(...stmt.destructure);
|
|
2849
|
+
push(names);
|
|
2850
|
+
renameBlock(stmt.body);
|
|
2851
|
+
pop();
|
|
2852
|
+
return;
|
|
2853
|
+
}
|
|
2854
|
+
case "ForInStatement":
|
|
2855
|
+
renameExpr(stmt.iterable);
|
|
2856
|
+
push([stmt.item]);
|
|
2857
|
+
renameBlock(stmt.body);
|
|
2858
|
+
pop();
|
|
2859
|
+
return;
|
|
2860
|
+
case "ForClassicStatement": {
|
|
2861
|
+
const initNames = [];
|
|
2862
|
+
if (stmt.init && stmt.init.kind === "Assignment" && stmt.init.identifier) {
|
|
2863
|
+
initNames.push(stmt.init.identifier);
|
|
2864
|
+
}
|
|
2865
|
+
push(initNames);
|
|
2866
|
+
if (stmt.init) renameStatement(stmt.init, false);
|
|
2867
|
+
if (stmt.test) renameExpr(stmt.test);
|
|
2868
|
+
if (stmt.update) renameExpr(stmt.update);
|
|
2869
|
+
renameBlock(stmt.body);
|
|
2870
|
+
pop();
|
|
2871
|
+
return;
|
|
2872
|
+
}
|
|
2873
|
+
case "WhileStatement":
|
|
2874
|
+
case "DoWhileStatement":
|
|
2875
|
+
renameExpr(stmt.test);
|
|
2876
|
+
renameBlock(stmt.body);
|
|
2877
|
+
return;
|
|
2878
|
+
case "DestructureStatement":
|
|
2879
|
+
renameExpr(stmt.expression);
|
|
2880
|
+
for (const b of stmt.bindings) if (b.defaultValue) renameExpr(b.defaultValue);
|
|
2881
|
+
if (topLevel) for (const b of stmt.bindings) b.name = rPlain(b.name);
|
|
2882
|
+
return;
|
|
2883
|
+
case "ThrowStatement":
|
|
2884
|
+
renameExpr(stmt.argument);
|
|
2885
|
+
return;
|
|
2886
|
+
case "TryStatement":
|
|
2887
|
+
renameBlock(stmt.block);
|
|
2888
|
+
if (stmt.catchBlock) {
|
|
2889
|
+
push(stmt.catchParam ? [stmt.catchParam] : []);
|
|
2890
|
+
renameBlock(stmt.catchBlock);
|
|
2891
|
+
pop();
|
|
2892
|
+
}
|
|
2893
|
+
if (stmt.finallyBlock) renameBlock(stmt.finallyBlock);
|
|
2894
|
+
return;
|
|
2895
|
+
case "BreakStatement":
|
|
2896
|
+
case "ContinueStatement":
|
|
2897
|
+
return;
|
|
2898
|
+
}
|
|
2899
|
+
}
|
|
2900
|
+
return { renameTopLevel };
|
|
2901
|
+
}
|
|
2902
|
+
function isUrl(spec) {
|
|
2903
|
+
return /^[a-z][a-z0-9+.-]*:\/\//i.test(spec);
|
|
2904
|
+
}
|
|
2905
|
+
function normalizeSegments(parts) {
|
|
2906
|
+
const out = [];
|
|
2907
|
+
for (const part of parts) {
|
|
2908
|
+
if (part === "" || part === ".") continue;
|
|
2909
|
+
if (part === "..") out.pop();
|
|
2910
|
+
else out.push(part);
|
|
2911
|
+
}
|
|
2912
|
+
return out.join("/");
|
|
2913
|
+
}
|
|
2914
|
+
function dirOf(path) {
|
|
2915
|
+
const slash = path.lastIndexOf("/");
|
|
2916
|
+
return slash < 0 ? "" : path.slice(0, slash);
|
|
2917
|
+
}
|
|
2918
|
+
function resolveSpecifier(spec, importerPath) {
|
|
2919
|
+
if (isUrl(spec)) {
|
|
2920
|
+
try {
|
|
2921
|
+
return new URL(spec).href;
|
|
2922
|
+
} catch {
|
|
2923
|
+
return null;
|
|
2924
|
+
}
|
|
2925
|
+
}
|
|
2926
|
+
if (isUrl(importerPath)) {
|
|
2927
|
+
try {
|
|
2928
|
+
return new URL(spec, importerPath).href;
|
|
2929
|
+
} catch {
|
|
2930
|
+
return null;
|
|
2931
|
+
}
|
|
2932
|
+
}
|
|
2933
|
+
if (spec.startsWith("/")) {
|
|
2934
|
+
return normalizeSegments(spec.split("/"));
|
|
2935
|
+
}
|
|
2936
|
+
if (spec.startsWith("./") || spec.startsWith("../")) {
|
|
2937
|
+
return normalizeSegments(`${dirOf(importerPath)}/${spec}`.split("/"));
|
|
2938
|
+
}
|
|
2939
|
+
return null;
|
|
2940
|
+
}
|
|
2941
|
+
function createMemoryResolver(files) {
|
|
2942
|
+
return {
|
|
2943
|
+
resolve: (spec, importer) => resolveSpecifier(spec, importer),
|
|
2944
|
+
load: (path) => {
|
|
2945
|
+
const src = files[path];
|
|
2946
|
+
if (src === void 0) throw new Error(`not found: ${path}`);
|
|
2947
|
+
return src;
|
|
2948
|
+
}
|
|
2949
|
+
};
|
|
2950
|
+
}
|
|
2951
|
+
async function defaultFetch(url) {
|
|
2952
|
+
if (typeof fetch !== "function") {
|
|
2953
|
+
throw new Error("global fetch is unavailable; cannot load URL imports");
|
|
2954
|
+
}
|
|
2955
|
+
const res = await fetch(url);
|
|
2956
|
+
if (!res.ok) throw new Error(`HTTP ${res.status}`);
|
|
2957
|
+
return res.text();
|
|
2958
|
+
}
|
|
2959
|
+
async function linkProject(options) {
|
|
2960
|
+
const { entry, files } = options;
|
|
2961
|
+
const fetchImpl = options.fetch ?? defaultFetch;
|
|
2962
|
+
const fetchDiagnostics = [];
|
|
2963
|
+
const sources = { ...files };
|
|
2964
|
+
const seen = /* @__PURE__ */ new Set();
|
|
2965
|
+
async function walk(path) {
|
|
2966
|
+
if (seen.has(path)) return;
|
|
2967
|
+
seen.add(path);
|
|
2968
|
+
if (sources[path] === void 0) {
|
|
2969
|
+
if (isUrl(path)) {
|
|
2970
|
+
try {
|
|
2971
|
+
sources[path] = await fetchImpl(path);
|
|
2972
|
+
} catch (err) {
|
|
2973
|
+
fetchDiagnostics.push({
|
|
2974
|
+
line: 0,
|
|
2975
|
+
column: 0,
|
|
2976
|
+
message: `Failed to fetch module "${path}": ${err.message ?? err}`,
|
|
2977
|
+
severity: "error"
|
|
2978
|
+
});
|
|
2979
|
+
return;
|
|
2980
|
+
}
|
|
2981
|
+
} else {
|
|
2982
|
+
return;
|
|
2983
|
+
}
|
|
2984
|
+
}
|
|
2985
|
+
let program;
|
|
2986
|
+
try {
|
|
2987
|
+
program = parse(sources[path]);
|
|
2988
|
+
} catch {
|
|
2989
|
+
return;
|
|
2990
|
+
}
|
|
2991
|
+
const children = [];
|
|
2992
|
+
for (const stmt of program.statements) {
|
|
2993
|
+
if (stmt.kind !== "Import") continue;
|
|
2994
|
+
const resolved = resolveSpecifier(stmt.source, path);
|
|
2995
|
+
if (resolved !== null) children.push(walk(resolved));
|
|
2996
|
+
}
|
|
2997
|
+
await Promise.all(children);
|
|
2998
|
+
}
|
|
2999
|
+
if (sources[entry] === void 0) {
|
|
3000
|
+
return {
|
|
3001
|
+
program: { statements: [], errors: [] },
|
|
3002
|
+
source: "",
|
|
3003
|
+
diagnostics: [
|
|
3004
|
+
{ line: 0, column: 0, message: `Entry module "${entry}" was not found.`, severity: "error" }
|
|
3005
|
+
],
|
|
3006
|
+
dependencies: []
|
|
3007
|
+
};
|
|
3008
|
+
}
|
|
3009
|
+
await walk(entry);
|
|
3010
|
+
const linked = linkProgram(sources[entry], entry, createMemoryResolver(sources));
|
|
3011
|
+
let source;
|
|
3012
|
+
try {
|
|
3013
|
+
source = printProgram(linked.program);
|
|
3014
|
+
} catch {
|
|
3015
|
+
source = sources[entry];
|
|
3016
|
+
}
|
|
3017
|
+
return {
|
|
3018
|
+
program: linked.program,
|
|
3019
|
+
source,
|
|
3020
|
+
diagnostics: [...fetchDiagnostics, ...linked.diagnostics],
|
|
3021
|
+
dependencies: linked.dependencies
|
|
3022
|
+
};
|
|
3023
|
+
}
|
|
2191
3024
|
function applyDelta(source, ops) {
|
|
2192
3025
|
const warnings = [];
|
|
2193
3026
|
const stateUpdates = {};
|
|
@@ -19578,7 +20411,7 @@ function syncFormState(oldEl, newEl) {
|
|
|
19578
20411
|
return;
|
|
19579
20412
|
}
|
|
19580
20413
|
if (oldEl instanceof HTMLSelectElement && newEl instanceof HTMLSelectElement) {
|
|
19581
|
-
if (
|
|
20414
|
+
if (oldEl.value !== newEl.value) {
|
|
19582
20415
|
oldEl.value = newEl.value;
|
|
19583
20416
|
}
|
|
19584
20417
|
return;
|
|
@@ -19587,20 +20420,43 @@ function syncFormState(oldEl, newEl) {
|
|
|
19587
20420
|
function syncInput(oldEl, newEl) {
|
|
19588
20421
|
if (oldEl.type === "checkbox" || oldEl.type === "radio") {
|
|
19589
20422
|
const desired2 = newEl.hasAttribute("checked") || newEl.checked;
|
|
19590
|
-
if (oldEl.checked !== desired2
|
|
20423
|
+
if (oldEl.checked !== desired2) {
|
|
19591
20424
|
oldEl.checked = desired2;
|
|
19592
20425
|
}
|
|
19593
20426
|
return;
|
|
19594
20427
|
}
|
|
19595
20428
|
const desired = newEl.getAttribute("value") ?? newEl.value ?? "";
|
|
19596
|
-
if (
|
|
19597
|
-
oldEl
|
|
20429
|
+
if (oldEl.value !== desired) {
|
|
20430
|
+
assignValuePreservingCaret(oldEl, desired);
|
|
19598
20431
|
}
|
|
19599
20432
|
}
|
|
19600
20433
|
function syncTextArea(oldEl, newEl) {
|
|
19601
20434
|
const desired = newEl.value ?? newEl.textContent ?? "";
|
|
19602
|
-
if (
|
|
19603
|
-
oldEl
|
|
20435
|
+
if (oldEl.value !== desired) {
|
|
20436
|
+
assignValuePreservingCaret(oldEl, desired);
|
|
20437
|
+
}
|
|
20438
|
+
}
|
|
20439
|
+
function assignValuePreservingCaret(el2, desired) {
|
|
20440
|
+
if (!isFocused(el2)) {
|
|
20441
|
+
el2.value = desired;
|
|
20442
|
+
return;
|
|
20443
|
+
}
|
|
20444
|
+
let start = null;
|
|
20445
|
+
let end = null;
|
|
20446
|
+
try {
|
|
20447
|
+
start = el2.selectionStart;
|
|
20448
|
+
end = el2.selectionEnd;
|
|
20449
|
+
} catch {
|
|
20450
|
+
}
|
|
20451
|
+
const prevLen = el2.value.length;
|
|
20452
|
+
el2.value = desired;
|
|
20453
|
+
if (start == null || end == null) return;
|
|
20454
|
+
const atEnd = start >= prevLen && end >= prevLen;
|
|
20455
|
+
const nextStart = atEnd ? desired.length : Math.min(start, desired.length);
|
|
20456
|
+
const nextEnd = atEnd ? desired.length : Math.min(end, desired.length);
|
|
20457
|
+
try {
|
|
20458
|
+
el2.setSelectionRange(nextStart, nextEnd);
|
|
20459
|
+
} catch {
|
|
19604
20460
|
}
|
|
19605
20461
|
}
|
|
19606
20462
|
function isFocused(el2) {
|
|
@@ -28779,6 +29635,7 @@ const ATTRIBUTE_THEME = "theme";
|
|
|
28779
29635
|
const ATTRIBUTE_STREAMING = "streaming";
|
|
28780
29636
|
const ATTRIBUTE_RESPONSE = "response";
|
|
28781
29637
|
const ATTRIBUTE_SHOW_ERRORS = "showerrors";
|
|
29638
|
+
const ATTRIBUTE_SRC = "src";
|
|
28782
29639
|
const STATE_ROUTE = "route";
|
|
28783
29640
|
function buildRouteObject(router) {
|
|
28784
29641
|
const path = router.getPath();
|
|
@@ -28902,6 +29759,25 @@ class AktionElement extends HTMLElement {
|
|
|
28902
29759
|
*/
|
|
28903
29760
|
__publicField(this, "forceFullRender", false);
|
|
28904
29761
|
__publicField(this, "parseErrors", []);
|
|
29762
|
+
/**
|
|
29763
|
+
* Diagnostics raised while loading a program from the `src` attribute
|
|
29764
|
+
* (fetch / link failures, unresolved imports). Tracked separately from
|
|
29765
|
+
* `parseErrors` so they survive the `replan()` that mounting the linked
|
|
29766
|
+
* program triggers, and are merged into the error banner + `error` event.
|
|
29767
|
+
*/
|
|
29768
|
+
__publicField(this, "srcDiagnostics", []);
|
|
29769
|
+
/**
|
|
29770
|
+
* Monotonic token guarding overlapping `src` loads. A rapid `src` change
|
|
29771
|
+
* (or a reconnect mid-fetch) bumps the token so a stale in-flight load
|
|
29772
|
+
* resolves into a no-op instead of clobbering the current program.
|
|
29773
|
+
*/
|
|
29774
|
+
__publicField(this, "srcLoadToken", 0);
|
|
29775
|
+
/**
|
|
29776
|
+
* True once `connectedCallback` has run at least once. Lets
|
|
29777
|
+
* `attributeChangedCallback` distinguish the initial attribute upgrade
|
|
29778
|
+
* (handled by `connectedCallback`) from a genuine later `src` change.
|
|
29779
|
+
*/
|
|
29780
|
+
__publicField(this, "hasConnected", false);
|
|
28905
29781
|
/**
|
|
28906
29782
|
* Token keys most recently applied by an in-script `$theme({...})`
|
|
28907
29783
|
* declaration. We remember them so the next render can clear stale
|
|
@@ -29000,10 +29876,12 @@ class AktionElement extends HTMLElement {
|
|
|
29000
29876
|
ATTRIBUTE_THEME,
|
|
29001
29877
|
ATTRIBUTE_STREAMING,
|
|
29002
29878
|
ATTRIBUTE_RESPONSE,
|
|
29003
|
-
ATTRIBUTE_SHOW_ERRORS
|
|
29879
|
+
ATTRIBUTE_SHOW_ERRORS,
|
|
29880
|
+
ATTRIBUTE_SRC
|
|
29004
29881
|
];
|
|
29005
29882
|
}
|
|
29006
29883
|
connectedCallback() {
|
|
29884
|
+
this.hasConnected = true;
|
|
29007
29885
|
ensureFontAwesomeLoaded(this.root);
|
|
29008
29886
|
this.registerWithDevtools();
|
|
29009
29887
|
this.applyThemeFromAttribute();
|
|
@@ -29013,6 +29891,11 @@ class AktionElement extends HTMLElement {
|
|
|
29013
29891
|
this.setResponse(responseAttr);
|
|
29014
29892
|
return;
|
|
29015
29893
|
}
|
|
29894
|
+
const srcAttr = this.getAttribute(ATTRIBUTE_SRC);
|
|
29895
|
+
if (srcAttr && !this.currentResponse) {
|
|
29896
|
+
void this.loadFromSrc(srcAttr);
|
|
29897
|
+
return;
|
|
29898
|
+
}
|
|
29016
29899
|
if (!this.currentResponse) {
|
|
29017
29900
|
const fallback = (this.textContent ?? "").trim();
|
|
29018
29901
|
if (fallback) {
|
|
@@ -29047,6 +29930,9 @@ class AktionElement extends HTMLElement {
|
|
|
29047
29930
|
const next = value ?? "";
|
|
29048
29931
|
if (next !== this.currentResponse) this.setResponse(next);
|
|
29049
29932
|
}
|
|
29933
|
+
if (name === ATTRIBUTE_SRC) {
|
|
29934
|
+
if (this.hasConnected && value) void this.loadFromSrc(value);
|
|
29935
|
+
}
|
|
29050
29936
|
}
|
|
29051
29937
|
/**
|
|
29052
29938
|
* Register HTTP interceptors used by the Aktion 0.5 HTTP layer (§22.1 of
|
|
@@ -29068,6 +29954,7 @@ class AktionElement extends HTMLElement {
|
|
|
29068
29954
|
this.state.rebind([]);
|
|
29069
29955
|
this.renderer.reset();
|
|
29070
29956
|
this.parseErrors = [];
|
|
29957
|
+
this.srcDiagnostics = [];
|
|
29071
29958
|
this.scheduleRender();
|
|
29072
29959
|
}
|
|
29073
29960
|
/**
|
|
@@ -29133,6 +30020,7 @@ class AktionElement extends HTMLElement {
|
|
|
29133
30020
|
this.state.rebind([]);
|
|
29134
30021
|
this.renderer.reset();
|
|
29135
30022
|
this.parseErrors = [];
|
|
30023
|
+
this.srcDiagnostics = [];
|
|
29136
30024
|
this.state.hydrate(payload.state);
|
|
29137
30025
|
this.scheduleRender();
|
|
29138
30026
|
}
|
|
@@ -29162,6 +30050,7 @@ class AktionElement extends HTMLElement {
|
|
|
29162
30050
|
this.state.rebind([]);
|
|
29163
30051
|
this.renderer.reset();
|
|
29164
30052
|
this.parseErrors = [];
|
|
30053
|
+
this.srcDiagnostics = [];
|
|
29165
30054
|
if (state) this.state.hydrate(state);
|
|
29166
30055
|
this.scheduleRender();
|
|
29167
30056
|
}
|
|
@@ -29172,6 +30061,88 @@ class AktionElement extends HTMLElement {
|
|
|
29172
30061
|
get sourceId() {
|
|
29173
30062
|
return this.compiledSourceId;
|
|
29174
30063
|
}
|
|
30064
|
+
/** Current `src` attribute value, or `null` when none is set. */
|
|
30065
|
+
get src() {
|
|
30066
|
+
return this.getAttribute(ATTRIBUTE_SRC);
|
|
30067
|
+
}
|
|
30068
|
+
set src(value) {
|
|
30069
|
+
if (value === null) this.removeAttribute(ATTRIBUTE_SRC);
|
|
30070
|
+
else this.setAttribute(ATTRIBUTE_SRC, value);
|
|
30071
|
+
}
|
|
30072
|
+
/**
|
|
30073
|
+
* Load the program from an external `.aktion` file referenced by the `src`
|
|
30074
|
+
* attribute. The entry is fetched relative to the document, linked through
|
|
30075
|
+
* the in-browser project linker (so an entry that `import`s other modules
|
|
30076
|
+
* resolves and fetches its whole graph), and mounted as a compiled program.
|
|
30077
|
+
*
|
|
30078
|
+
* A monotonic token guards against overlapping loads: a rapid `src` change
|
|
30079
|
+
* or a reconnect mid-fetch bumps the token, so a stale in-flight load
|
|
30080
|
+
* resolves into a no-op instead of clobbering the current program. Fetch /
|
|
30081
|
+
* link failures and unresolved imports surface through the same error banner
|
|
30082
|
+
* and `error` event as parse errors.
|
|
30083
|
+
*/
|
|
30084
|
+
async loadFromSrc(src) {
|
|
30085
|
+
const token = this.srcLoadToken += 1;
|
|
30086
|
+
this.srcDiagnostics = [];
|
|
30087
|
+
let entryUrl;
|
|
30088
|
+
try {
|
|
30089
|
+
const base = typeof document !== "undefined" ? document.baseURI : void 0;
|
|
30090
|
+
entryUrl = new URL(src, base).href;
|
|
30091
|
+
} catch {
|
|
30092
|
+
this.reportSrcError(`Invalid src "${src}".`);
|
|
30093
|
+
return;
|
|
30094
|
+
}
|
|
30095
|
+
let entryText;
|
|
30096
|
+
try {
|
|
30097
|
+
if (typeof fetch !== "function") throw new Error("global fetch is unavailable");
|
|
30098
|
+
const response = await fetch(entryUrl);
|
|
30099
|
+
if (!response.ok) throw new Error(`HTTP ${response.status}`);
|
|
30100
|
+
entryText = await response.text();
|
|
30101
|
+
} catch (err) {
|
|
30102
|
+
if (this.isStaleSrcLoad(token)) return;
|
|
30103
|
+
this.reportSrcError(`Failed to load "${src}": ${errorMessage(err)}`);
|
|
30104
|
+
return;
|
|
30105
|
+
}
|
|
30106
|
+
if (this.isStaleSrcLoad(token)) return;
|
|
30107
|
+
let result;
|
|
30108
|
+
try {
|
|
30109
|
+
result = await linkProject({ entry: entryUrl, files: { [entryUrl]: entryText } });
|
|
30110
|
+
} catch (err) {
|
|
30111
|
+
if (this.isStaleSrcLoad(token)) return;
|
|
30112
|
+
this.reportSrcError(`Failed to link "${src}": ${errorMessage(err)}`);
|
|
30113
|
+
return;
|
|
30114
|
+
}
|
|
30115
|
+
if (this.isStaleSrcLoad(token)) return;
|
|
30116
|
+
this.mountCompiled(
|
|
30117
|
+
defineCompiledProgram({
|
|
30118
|
+
__aktionCompiled: COMPILED_PROGRAM_VERSION,
|
|
30119
|
+
program: result.program,
|
|
30120
|
+
source: result.source,
|
|
30121
|
+
path: entryUrl
|
|
30122
|
+
})
|
|
30123
|
+
);
|
|
30124
|
+
this.srcDiagnostics = result.diagnostics.filter((d) => d.severity !== "warning").map((d) => d.line > 0 ? `Line ${d.line}: ${d.message}` : d.message);
|
|
30125
|
+
}
|
|
30126
|
+
/** A `src` load is stale if a newer one started or the element detached. */
|
|
30127
|
+
isStaleSrcLoad(token) {
|
|
30128
|
+
return token !== this.srcLoadToken || !this.isConnected;
|
|
30129
|
+
}
|
|
30130
|
+
/**
|
|
30131
|
+
* Surface a `src`-loading failure: record it, refresh the banner, and
|
|
30132
|
+
* bubble an `error` event so host pages can react (mirrors how parse
|
|
30133
|
+
* errors are reported).
|
|
30134
|
+
*/
|
|
30135
|
+
reportSrcError(message) {
|
|
30136
|
+
if (!this.srcDiagnostics.includes(message)) {
|
|
30137
|
+
this.srcDiagnostics = [...this.srcDiagnostics, message];
|
|
30138
|
+
}
|
|
30139
|
+
this.updateErrorBanner();
|
|
30140
|
+
this.dispatchEvent(new CustomEvent("error", {
|
|
30141
|
+
detail: { errors: [{ line: 0, column: 0, message }] },
|
|
30142
|
+
bubbles: true,
|
|
30143
|
+
composed: true
|
|
30144
|
+
}));
|
|
30145
|
+
}
|
|
29175
30146
|
/** Append a streaming chunk and re-render. */
|
|
29176
30147
|
appendChunk(chunk) {
|
|
29177
30148
|
if (chunk === null || chunk === void 0) return;
|
|
@@ -29216,6 +30187,7 @@ class AktionElement extends HTMLElement {
|
|
|
29216
30187
|
this.renderer.reset();
|
|
29217
30188
|
this.programDirty = true;
|
|
29218
30189
|
this.parseErrors = [];
|
|
30190
|
+
this.srcDiagnostics = [];
|
|
29219
30191
|
this.errorEl.hidden = true;
|
|
29220
30192
|
this.errorEl.replaceChildren();
|
|
29221
30193
|
this.rootEl.replaceChildren();
|
|
@@ -29600,16 +30572,17 @@ class AktionElement extends HTMLElement {
|
|
|
29600
30572
|
}
|
|
29601
30573
|
}
|
|
29602
30574
|
updateErrorBanner() {
|
|
29603
|
-
|
|
30575
|
+
const messages = [...this.parseErrors, ...this.srcDiagnostics];
|
|
30576
|
+
if (!this.showErrors || this.streaming || messages.length === 0) {
|
|
29604
30577
|
this.errorEl.hidden = true;
|
|
29605
30578
|
this.errorEl.replaceChildren();
|
|
29606
30579
|
return;
|
|
29607
30580
|
}
|
|
29608
30581
|
this.errorEl.hidden = false;
|
|
29609
30582
|
const title = document.createElement("div");
|
|
29610
|
-
title.textContent = `${
|
|
30583
|
+
title.textContent = `${messages.length} parse issue${messages.length === 1 ? "" : "s"} (rendered partial UI):`;
|
|
29611
30584
|
const list = document.createElement("ul");
|
|
29612
|
-
for (const message of
|
|
30585
|
+
for (const message of messages.slice(0, 5)) {
|
|
29613
30586
|
const li = document.createElement("li");
|
|
29614
30587
|
li.textContent = message;
|
|
29615
30588
|
list.append(li);
|
|
@@ -29662,6 +30635,10 @@ function parseBooleanAttribute(value) {
|
|
|
29662
30635
|
if (normalized === ATTRIBUTE_SHOW_ERRORS) return true;
|
|
29663
30636
|
return false;
|
|
29664
30637
|
}
|
|
30638
|
+
function errorMessage(err) {
|
|
30639
|
+
if (err instanceof Error && err.message) return err.message;
|
|
30640
|
+
return String(err);
|
|
30641
|
+
}
|
|
29665
30642
|
function defineElement() {
|
|
29666
30643
|
if (!customElements.get(AktionElement.tagName)) {
|
|
29667
30644
|
customElements.define(AktionElement.tagName, AktionElement);
|