@lovable.dev/workflows-sdk 0.0.0-dev.21 → 0.0.0-dev.23
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 +24 -15
- package/dist/{branch-metadata-D3f-8DT-.js → branch-metadata-IXuazOmY.js} +1 -1
- package/dist/{context-escapes-DPKbDPIx.js → context-escapes-x0J0HUgC.js} +1 -1
- package/dist/{duplicate-ids-C4Ug3kFs.js → duplicate-ids-NnTrnieX.js} +7 -2
- package/dist/{generate-CrIdSenf.js → generate-BNbOHB23.js} +11 -7
- package/dist/{graph-BDLuv4B_.js → graph-Qx9mvqnC.js} +56 -8
- package/dist/index.d.ts +10 -0
- package/dist/index.js +1 -1
- package/dist/{nested-operations-IG6_OTsi.js → nested-operations-DYVa5c5A.js} +1 -1
- package/dist/{operation-descriptions-DWsquPYE.js → operation-descriptions-BLZC8bxV.js} +1 -1
- package/dist/{step-metadata-CPpfxR2q.js → step-metadata-MjyYQjOy.js} +39 -2
- package/dist/vite.js +1 -1
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -83,7 +83,11 @@ await Promise.all(
|
|
|
83
83
|
```
|
|
84
84
|
|
|
85
85
|
Group IDs are unique per workflow callsite. Ordinary sequential steps and
|
|
86
|
-
fixed `Promise.all([stepA, stepB])` branches do not need a group.
|
|
86
|
+
fixed `Promise.all([stepA, stepB])` branches do not need a group. For dynamic
|
|
87
|
+
sequential work, await one step directly as the only statement in a `for...of`
|
|
88
|
+
loop. For dynamic parallel work, use the mapped `Promise.all()` form above;
|
|
89
|
+
manifest generation rejects loops that collect step promises for a later
|
|
90
|
+
`Promise.all()`.
|
|
87
91
|
|
|
88
92
|
## Triggers
|
|
89
93
|
|
|
@@ -314,10 +318,12 @@ Sequential awaited `ctx.step("name", callback, options)` calls produce order edg
|
|
|
314
318
|
`await Promise.all([ctx.step(...), ctx.step(...)])` produces parallel branches
|
|
315
319
|
that join at the next step. A `Promise.all()` mapped over a collection with the
|
|
316
320
|
step ID template `step-${item.id}` produces one dynamic parallel node labeled
|
|
317
|
-
from `meta.group.label`.
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
+
from `meta.group.label`. A `for...of` loop whose only statement directly awaits
|
|
322
|
+
a step with such an ID template produces one dynamic sequential `loop` node.
|
|
323
|
+
Returned step promises work too. Keep step IDs literal outside these dynamic
|
|
324
|
+
forms. A `try` block retains its durable operations when the `catch` only handles
|
|
325
|
+
the error in ordinary code. Durable operations in a `catch` remain visible in a
|
|
326
|
+
partial graph because edges do not encode error outcomes.
|
|
321
327
|
|
|
322
328
|
An `if` whose body contains durable operations produces a `branch` node. Every
|
|
323
329
|
durable operation inside it includes an outer-to-inner `meta.branches` path;
|
|
@@ -336,15 +342,16 @@ meta: {
|
|
|
336
342
|
| Field | Meaning |
|
|
337
343
|
| --- | --- |
|
|
338
344
|
| `nodes[].id` | Unique occurrence ID within this graph; use as the UI node key |
|
|
339
|
-
| `nodes[].kind` | Durable operation, `branch`, `parallel`, or `unknown` |
|
|
345
|
+
| `nodes[].kind` | Durable operation, `branch`, `parallel`, `loop`, or `unknown` |
|
|
340
346
|
| `nodes[].stepId` | Runtime durable ID for every statically known operation |
|
|
341
347
|
| `nodes[].description` | User-facing description for every known durable operation and branch |
|
|
342
348
|
| `nodes[].branchId` | Stable ID for an inferred `if` node |
|
|
343
349
|
| `nodes[].condition` | Source expression from the corresponding `if` statement |
|
|
344
|
-
| `nodes[].groupId` | Stable callsite ID for a dynamic parallel node |
|
|
345
|
-
| `nodes[].cardinality` | `dynamic` for a runtime-sized
|
|
346
|
-
| `nodes[].
|
|
347
|
-
| `nodes[].operation.
|
|
350
|
+
| `nodes[].groupId` | Stable callsite ID for a dynamic parallel or loop node |
|
|
351
|
+
| `nodes[].cardinality` | `dynamic` for a runtime-sized repeated operation |
|
|
352
|
+
| `nodes[].execution` | `sequential` for a dynamic loop node |
|
|
353
|
+
| `nodes[].operation.kind` | Durable operation repeated by a dynamic node |
|
|
354
|
+
| `nodes[].operation.stepIdTemplate` | Display template for steps in a dynamic node |
|
|
348
355
|
| `nodes[].operation.description` | User-facing description shared by the repeated steps |
|
|
349
356
|
| `nodes[].label` | Step ID, branch description, group label, or explanation of unsupported code |
|
|
350
357
|
| `edges[]` | Order edges or branch edges with an AST-derived boolean `outcome`, referencing node IDs |
|
|
@@ -364,11 +371,13 @@ Graphs have `source: "inferred"` and `scope: "handler"`. They describe source
|
|
|
364
371
|
structure, not run history or data dependencies, and exclude middleware and
|
|
365
372
|
initialization. A mapped `Promise.all` is complete when its callback directly
|
|
366
373
|
returns `ctx.step()` with a template-literal ID derived from a callback parameter.
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
374
|
+
A `for...of` loop is complete when its only statement directly awaits the same
|
|
375
|
+
shape of step using the loop variable. Other loops, switch statements,
|
|
376
|
+
conditional expressions, helper calls, dynamic step IDs, and unawaited steps
|
|
377
|
+
produce `unknown` nodes and `complete: false`; steps inside unsupported code are
|
|
378
|
+
not expanded. The UI should show these unknown nodes and mark partial graphs.
|
|
379
|
+
Transforms that rewrite the handler may also produce a partial graph. A handler
|
|
380
|
+
with no steps can have an empty graph.
|
|
372
381
|
|
|
373
382
|
A step body is one atomic execution unit. Manifest generation rejects statically
|
|
374
383
|
visible durable calls inside it, including `ctx.step`, `ctx.sleep`, `ctx.now`,
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { t as defaultDurableId } from "./durable-ids-LsygHSZC.js";
|
|
2
|
-
import { loadTypeScript, t as workflowHandlerSource } from "./graph-
|
|
2
|
+
import { loadTypeScript, t as workflowHandlerSource } from "./graph-Qx9mvqnC.js";
|
|
3
3
|
//#region src/manifests/duplicate-ids.ts
|
|
4
4
|
/** Where an explicit `{ id }` would sit for each operation. */
|
|
5
5
|
const optionsArgument = {
|
|
@@ -83,6 +83,11 @@ async function findDuplicateOperationIds(handler) {
|
|
|
83
83
|
case "step": return;
|
|
84
84
|
}
|
|
85
85
|
}
|
|
86
|
+
function repeatedLoopRegion(parent, child) {
|
|
87
|
+
if (ts.isForOfStatement(parent) || ts.isForInStatement(parent)) return parent.statement === child;
|
|
88
|
+
if (ts.isForStatement(parent)) return parent.statement === child || parent.condition === child || parent.incrementor === child;
|
|
89
|
+
return ts.isWhileStatement(parent) || ts.isDoStatement(parent);
|
|
90
|
+
}
|
|
86
91
|
function placement(call) {
|
|
87
92
|
const branches = /* @__PURE__ */ new Map();
|
|
88
93
|
let repeatable = false;
|
|
@@ -96,7 +101,7 @@ async function findDuplicateOperationIds(handler) {
|
|
|
96
101
|
if (parent.whenTrue === child) branches.set(String(parent.pos), "true");
|
|
97
102
|
else if (parent.whenFalse === child) branches.set(String(parent.pos), "false");
|
|
98
103
|
} else if (ts.isCaseClause(parent) || ts.isDefaultClause(parent)) branches.set(String(parent.parent.pos), String(parent.parent.clauses.indexOf(parent)));
|
|
99
|
-
else if (parent !== fn && (
|
|
104
|
+
else if (parent !== fn && (repeatedLoopRegion(parent, child) || ts.isFunctionLike(parent))) repeatable = true;
|
|
100
105
|
child = parent;
|
|
101
106
|
parent = parent.parent;
|
|
102
107
|
}
|
|
@@ -183,13 +183,13 @@ function serializeSchema(schema, direction, label) {
|
|
|
183
183
|
}
|
|
184
184
|
}
|
|
185
185
|
async function generateManifests(definition) {
|
|
186
|
-
const { extractWorkflowGraph } = await import("./graph-
|
|
187
|
-
const { findBranchMetadataIssues } = await import("./branch-metadata-
|
|
188
|
-
const { findWorkflowContextEscapes } = await import("./context-escapes-
|
|
189
|
-
const { findDuplicateOperationIds } = await import("./duplicate-ids-
|
|
190
|
-
const { findNestedDurableOperations } = await import("./nested-operations-
|
|
191
|
-
const { findOperationDescriptionIssues } = await import("./operation-descriptions-
|
|
192
|
-
const { findStepMetadataIssues } = await import("./step-metadata-
|
|
186
|
+
const { extractWorkflowGraph } = await import("./graph-Qx9mvqnC.js");
|
|
187
|
+
const { findBranchMetadataIssues } = await import("./branch-metadata-IXuazOmY.js");
|
|
188
|
+
const { findWorkflowContextEscapes } = await import("./context-escapes-x0J0HUgC.js");
|
|
189
|
+
const { findDuplicateOperationIds } = await import("./duplicate-ids-NnTrnieX.js");
|
|
190
|
+
const { findNestedDurableOperations } = await import("./nested-operations-DYVa5c5A.js");
|
|
191
|
+
const { findOperationDescriptionIssues } = await import("./operation-descriptions-BLZC8bxV.js");
|
|
192
|
+
const { findStepMetadataIssues } = await import("./step-metadata-MjyYQjOy.js");
|
|
193
193
|
const collection = registerWorkflows(definition);
|
|
194
194
|
const manifests = [];
|
|
195
195
|
for (const workflow of collection.workflows) {
|
|
@@ -220,6 +220,10 @@ async function generateManifests(definition) {
|
|
|
220
220
|
const step = metadataIssue.stepId ? `ctx.step(${JSON.stringify(metadataIssue.stepId)})` : "ctx.step()";
|
|
221
221
|
throw new Error(`@lovable.dev/workflows-sdk: workflow "${workflow.id}" ${step} is declared in a loop or callback and must include a static { meta: { group: { id: "...", label: "..." } } }`);
|
|
222
222
|
}
|
|
223
|
+
if (metadataIssue?.kind === "loop-form") {
|
|
224
|
+
const step = metadataIssue.stepId ? `ctx.step(${JSON.stringify(metadataIssue.stepId)})` : "ctx.step()";
|
|
225
|
+
throw new Error(`@lovable.dev/workflows-sdk: workflow "${workflow.id}" ${step} uses an unsupported loop form; await ctx.step() directly as the only statement in a for...of loop for sequential execution, or use Promise.all(items.map((item) => ctx.step(...))) for parallel execution`);
|
|
226
|
+
}
|
|
223
227
|
if (metadataIssue?.kind === "duplicate-group") throw new Error(`@lovable.dev/workflows-sdk: workflow "${workflow.id}" uses group id ${JSON.stringify(metadataIssue.groupId)} at more than one repeated step callsite; every group id must identify one callsite`);
|
|
224
228
|
const operationDescriptionIssue = (await findOperationDescriptionIssues(workflow.handler))[0];
|
|
225
229
|
if (operationDescriptionIssue) {
|
|
@@ -152,6 +152,27 @@ async function extractWorkflowGraph(handler) {
|
|
|
152
152
|
template
|
|
153
153
|
};
|
|
154
154
|
}
|
|
155
|
+
function sequentialLoopStep(node) {
|
|
156
|
+
if (node.awaitModifier || !ts.isVariableDeclarationList(node.initializer)) return void 0;
|
|
157
|
+
const declarations = node.initializer.declarations;
|
|
158
|
+
if (declarations.length !== 1) return void 0;
|
|
159
|
+
const declaration = declarations[0];
|
|
160
|
+
if (!ts.isIdentifier(declaration.name) || declaration.initializer) return void 0;
|
|
161
|
+
let statement = node.statement;
|
|
162
|
+
if (ts.isBlock(statement)) statement = statement.statements.length === 1 ? statement.statements[0] : void 0;
|
|
163
|
+
if (!statement || !ts.isExpressionStatement(statement)) return void 0;
|
|
164
|
+
let body = statement.expression;
|
|
165
|
+
while (ts.isParenthesizedExpression(body)) body = body.expression;
|
|
166
|
+
if (!ts.isAwaitExpression(body)) return void 0;
|
|
167
|
+
let awaited = body.expression;
|
|
168
|
+
while (ts.isParenthesizedExpression(awaited)) awaited = awaited.expression;
|
|
169
|
+
if (!durableCall(awaited) || awaited.expression.name.text !== "step") return;
|
|
170
|
+
const template = stepIdTemplate(awaited.arguments[0], /* @__PURE__ */ new Set([declaration.name.text]));
|
|
171
|
+
return template === void 0 ? void 0 : {
|
|
172
|
+
call: awaited,
|
|
173
|
+
template
|
|
174
|
+
};
|
|
175
|
+
}
|
|
155
176
|
function readableOptions(node) {
|
|
156
177
|
return node && ts.isObjectLiteralExpression(node) && node.properties.every(ts.isPropertyAssignment) ? node : void 0;
|
|
157
178
|
}
|
|
@@ -427,25 +448,28 @@ async function extractWorkflowGraph(handler) {
|
|
|
427
448
|
if (statement.elseStatement) visit(statement.elseStatement);
|
|
428
449
|
return result;
|
|
429
450
|
}
|
|
430
|
-
function statementFlow(normal, thrown = path([], false), returned = path([], false)) {
|
|
451
|
+
function statementFlow(normal, thrown = path([], false), returned = path([], false), stopped = path([], false)) {
|
|
431
452
|
return {
|
|
432
453
|
normal,
|
|
433
454
|
thrown,
|
|
434
|
-
returned
|
|
455
|
+
returned,
|
|
456
|
+
stopped
|
|
435
457
|
};
|
|
436
458
|
}
|
|
437
459
|
function statements(items, parents, branchDepth) {
|
|
438
460
|
let normal = path(parents);
|
|
439
461
|
let thrown = path([], false);
|
|
440
462
|
let returned = path([], false);
|
|
463
|
+
let stopped = path([], false);
|
|
441
464
|
for (const statement of items) {
|
|
442
465
|
if (!normal.reachable) break;
|
|
443
466
|
const flow = walkStatement(statement, normal.tails, branchDepth);
|
|
444
467
|
normal = flow.normal;
|
|
445
468
|
thrown = mergePaths(thrown, flow.thrown);
|
|
446
469
|
returned = mergePaths(returned, flow.returned);
|
|
470
|
+
stopped = mergePaths(stopped, flow.stopped);
|
|
447
471
|
}
|
|
448
|
-
return statementFlow(normal, thrown, returned);
|
|
472
|
+
return statementFlow(normal, thrown, returned, stopped);
|
|
449
473
|
}
|
|
450
474
|
function walkStatement(statement, parents, branchDepth) {
|
|
451
475
|
if (ts.isBlock(statement)) return statements(statement.statements, parents, branchDepth);
|
|
@@ -461,7 +485,10 @@ async function extractWorkflowGraph(handler) {
|
|
|
461
485
|
return statementFlow(path([], false), mergePaths(result.thrown, path(result.tails)));
|
|
462
486
|
}
|
|
463
487
|
if (ts.isVariableStatement(statement)) {
|
|
464
|
-
if (statement.declarationList.declarations.some((item) => contains(item.name, (child) => ts.isIdentifier(child) && (child.text === "Promise" || child.text === context))))
|
|
488
|
+
if (statement.declarationList.declarations.some((item) => contains(item.name, (child) => ts.isIdentifier(child) && (child.text === "Promise" || child.text === context)))) {
|
|
489
|
+
const tails = unknown("Shadowed context or Promise bindings are not supported yet", parents);
|
|
490
|
+
return statementFlow(path([], false), path([], false), path([], false), path(tails));
|
|
491
|
+
}
|
|
465
492
|
let tails = parents;
|
|
466
493
|
let thrown = path([], false);
|
|
467
494
|
for (const item of statement.declarationList.declarations) {
|
|
@@ -500,7 +527,7 @@ async function extractWorkflowGraph(handler) {
|
|
|
500
527
|
}] : branchTails;
|
|
501
528
|
const thenFlow = walkStatement(statement.thenStatement, thenParents, branchDepth + 1);
|
|
502
529
|
const elseFlow = statement.elseStatement ? walkStatement(statement.elseStatement, elseParents, branchDepth + 1) : statementFlow(path(elseParents));
|
|
503
|
-
return statementFlow(mergePaths(thenFlow.normal, elseFlow.normal), mergePaths(conditionFlow.thrown, thenFlow.thrown, elseFlow.thrown), mergePaths(thenFlow.returned, elseFlow.returned));
|
|
530
|
+
return statementFlow(mergePaths(thenFlow.normal, elseFlow.normal), mergePaths(conditionFlow.thrown, thenFlow.thrown, elseFlow.thrown), mergePaths(thenFlow.returned, elseFlow.returned), mergePaths(thenFlow.stopped, elseFlow.stopped));
|
|
504
531
|
}
|
|
505
532
|
if (ts.isTryStatement(statement)) {
|
|
506
533
|
const tryFlow = walkStatement(statement.tryBlock, parents, branchDepth);
|
|
@@ -513,15 +540,36 @@ async function extractWorkflowGraph(handler) {
|
|
|
513
540
|
const normal = mergePaths(tryFlow.normal, catchFlow.normal);
|
|
514
541
|
const thrown = catchBlock ? catchFlow.thrown : tryFlow.thrown;
|
|
515
542
|
const returned = mergePaths(tryFlow.returned, catchFlow.returned);
|
|
516
|
-
const
|
|
543
|
+
const stopped = mergePaths(tryFlow.stopped, catchFlow.stopped);
|
|
544
|
+
const flow = statementFlow(normal, thrown, returned, stopped);
|
|
517
545
|
if (!statement.finallyBlock) return flow;
|
|
518
546
|
const finallyHasDurableOperations = contains(statement.finallyBlock, durableCall);
|
|
519
547
|
const finallyHasAbruptCompletion = contains(statement.finallyBlock, (node) => ts.isReturnStatement(node) || ts.isThrowStatement(node), true);
|
|
520
548
|
if (!finallyHasDurableOperations && !finallyHasAbruptCompletion) return flow;
|
|
521
|
-
const finallyParents = mergePaths(normal, thrown, returned);
|
|
549
|
+
const finallyParents = mergePaths(normal, thrown, returned, stopped);
|
|
522
550
|
const finallyFlow = walkStatement(statement.finallyBlock, finallyParents.tails, branchDepth);
|
|
523
551
|
const completedFinally = finallyFlow.normal.reachable;
|
|
524
|
-
return statementFlow(path(finallyFlow.normal.tails, normal.reachable && completedFinally), mergePaths(finallyFlow.thrown, path(finallyFlow.normal.tails, thrown.reachable && completedFinally)), mergePaths(finallyFlow.returned, path(finallyFlow.normal.tails, returned.reachable && completedFinally)));
|
|
552
|
+
return statementFlow(path(finallyFlow.normal.tails, normal.reachable && completedFinally), mergePaths(finallyFlow.thrown, path(finallyFlow.normal.tails, thrown.reachable && completedFinally)), mergePaths(finallyFlow.returned, path(finallyFlow.normal.tails, returned.reachable && completedFinally)), mergePaths(finallyFlow.stopped, path(finallyFlow.normal.tails, stopped.reachable && completedFinally)));
|
|
553
|
+
}
|
|
554
|
+
if (ts.isForOfStatement(statement)) {
|
|
555
|
+
const repeated = sequentialLoopStep(statement);
|
|
556
|
+
if (repeated) {
|
|
557
|
+
const iterable = expression(statement.expression, parents);
|
|
558
|
+
const metadata = stepMetadata(repeated.call);
|
|
559
|
+
const tails = metadata?.group ? addNode({
|
|
560
|
+
kind: "loop",
|
|
561
|
+
groupId: metadata.group.id,
|
|
562
|
+
cardinality: "dynamic",
|
|
563
|
+
execution: "sequential",
|
|
564
|
+
operation: {
|
|
565
|
+
kind: "step",
|
|
566
|
+
stepIdTemplate: repeated.template,
|
|
567
|
+
description: metadata.description
|
|
568
|
+
},
|
|
569
|
+
label: metadata.group.label
|
|
570
|
+
}, iterable.tails) : unknown("Dynamic sequential steps need static group metadata", iterable.tails);
|
|
571
|
+
return statementFlow(path(tails), mergePaths(iterable.thrown, path(tails)));
|
|
572
|
+
}
|
|
525
573
|
}
|
|
526
574
|
if (ts.isEmptyStatement(statement)) return statementFlow(path(parents));
|
|
527
575
|
return statementFlow(path(unknown("Loops and other control flow are not supported yet", parents)));
|
package/dist/index.d.ts
CHANGED
|
@@ -82,6 +82,16 @@ type WorkflowGraphNodeDetails = {
|
|
|
82
82
|
stepIdTemplate: string;
|
|
83
83
|
description: string;
|
|
84
84
|
};
|
|
85
|
+
} | {
|
|
86
|
+
kind: "loop";
|
|
87
|
+
groupId: string;
|
|
88
|
+
cardinality: "dynamic";
|
|
89
|
+
execution: "sequential";
|
|
90
|
+
operation: {
|
|
91
|
+
kind: "step";
|
|
92
|
+
stepIdTemplate: string;
|
|
93
|
+
description: string;
|
|
94
|
+
};
|
|
85
95
|
} | {
|
|
86
96
|
kind: "approve";
|
|
87
97
|
stepId: string;
|
package/dist/index.js
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { a as defineSchedule, c as weekly, i as registerWorkflows, n as createMiddleware, o as daily, r as createWorkflow, s as hourly, t as generateManifests } from "./generate-
|
|
1
|
+
import { a as defineSchedule, c as weekly, i as registerWorkflows, n as createMiddleware, o as daily, r as createWorkflow, s as hourly, t as generateManifests } from "./generate-BNbOHB23.js";
|
|
2
2
|
import { t as defaultDurableId } from "./durable-ids-LsygHSZC.js";
|
|
3
3
|
import { WorkflowRequestParseError, inMemoryRunStore, parseWorkflowRequest, runWorkflow } from "@tanstack/workflow-core";
|
|
4
4
|
//#region src/stacks/tanstack/sse.ts
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { loadTypeScript, t as workflowHandlerSource } from "./graph-
|
|
1
|
+
import { loadTypeScript, t as workflowHandlerSource } from "./graph-Qx9mvqnC.js";
|
|
2
2
|
//#region src/manifests/step-metadata.ts
|
|
3
3
|
async function findStepMetadataIssues(handler) {
|
|
4
4
|
const api = await loadTypeScript();
|
|
@@ -22,19 +22,56 @@ async function findStepMetadataIssues(handler) {
|
|
|
22
22
|
if ((ts.isIdentifier(entry.name) || ts.isStringLiteral(entry.name) ? entry.name.text : void 0) === name) return entry.initializer;
|
|
23
23
|
}
|
|
24
24
|
}
|
|
25
|
+
function repeatedLoopRegion(parent, child) {
|
|
26
|
+
if (ts.isForOfStatement(parent) || ts.isForInStatement(parent)) return parent.statement === child;
|
|
27
|
+
if (ts.isForStatement(parent)) return parent.statement === child || parent.condition === child || parent.incrementor === child;
|
|
28
|
+
return ts.isWhileStatement(parent) || ts.isDoStatement(parent);
|
|
29
|
+
}
|
|
25
30
|
function repeatable(call) {
|
|
31
|
+
let child = call;
|
|
26
32
|
let parent = call.parent;
|
|
27
33
|
while (parent && parent !== fn) {
|
|
28
|
-
if (
|
|
34
|
+
if (repeatedLoopRegion(parent, child) || ts.isFunctionLike(parent)) return true;
|
|
35
|
+
child = parent;
|
|
29
36
|
parent = parent.parent;
|
|
30
37
|
}
|
|
31
38
|
return false;
|
|
32
39
|
}
|
|
40
|
+
function loopAncestors(call) {
|
|
41
|
+
const loops = [];
|
|
42
|
+
let child = call;
|
|
43
|
+
let parent = call.parent;
|
|
44
|
+
while (parent && parent !== fn) {
|
|
45
|
+
if (repeatedLoopRegion(parent, child)) loops.push(parent);
|
|
46
|
+
child = parent;
|
|
47
|
+
parent = parent.parent;
|
|
48
|
+
}
|
|
49
|
+
return loops;
|
|
50
|
+
}
|
|
51
|
+
function isDirectSequentialLoopStep(loop, call) {
|
|
52
|
+
if (!ts.isForOfStatement(loop) || loop.awaitModifier || !ts.isVariableDeclarationList(loop.initializer)) return false;
|
|
53
|
+
const declarations = loop.initializer.declarations;
|
|
54
|
+
if (declarations.length !== 1 || !ts.isIdentifier(declarations[0].name) || declarations[0].initializer) return false;
|
|
55
|
+
let statement = loop.statement;
|
|
56
|
+
if (ts.isBlock(statement)) statement = statement.statements.length === 1 ? statement.statements[0] : void 0;
|
|
57
|
+
if (!statement || !ts.isExpressionStatement(statement)) return false;
|
|
58
|
+
let expression = statement.expression;
|
|
59
|
+
while (ts.isParenthesizedExpression(expression)) expression = expression.expression;
|
|
60
|
+
if (!ts.isAwaitExpression(expression)) return false;
|
|
61
|
+
let awaited = expression.expression;
|
|
62
|
+
while (ts.isParenthesizedExpression(awaited)) awaited = awaited.expression;
|
|
63
|
+
return awaited === call;
|
|
64
|
+
}
|
|
33
65
|
const issues = [];
|
|
34
66
|
const groups = /* @__PURE__ */ new Set();
|
|
35
67
|
const visit = (node) => {
|
|
36
68
|
if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === context && node.expression.name.text === "step") {
|
|
37
69
|
const stepId = literalString(node.arguments[0]);
|
|
70
|
+
const loops = loopAncestors(node);
|
|
71
|
+
if (loops.length > 0 && (loops.length !== 1 || !isDirectSequentialLoopStep(loops[0], node))) issues.push({
|
|
72
|
+
kind: "loop-form",
|
|
73
|
+
...stepId === void 0 ? {} : { stepId }
|
|
74
|
+
});
|
|
38
75
|
const meta = property(node.arguments[2], "meta");
|
|
39
76
|
if (literalString(property(meta, "description")) === void 0) issues.push({
|
|
40
77
|
kind: "description",
|
package/dist/vite.js
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { t as generateManifests } from "./generate-
|
|
1
|
+
import { t as generateManifests } from "./generate-BNbOHB23.js";
|
|
2
2
|
import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
|
|
3
3
|
import { createServer } from "vite";
|
|
4
4
|
import { lstat, mkdir, mkdtemp, readdir, rename, rm, writeFile } from "node:fs/promises";
|