@itmetsam/samurai-framework 0.2.3 → 0.4.0

package/dist/flows/core/nodes/define.d.ts

@@ -0,0 +1,132 @@
+import type { FlowNodeModel } from "../schema.js";
+/** A problem `checkFlow` or a node's `validate` reports */
+export interface FlowProblem {
+    level: "error" | "warning";
+    message: string;
+    nodeId?: string;
+}
+/** What a node's `validate` can read besides the node itself */
+export interface NodeCtx {
+    /** The definition's `label`: the one place a node's name is written */
+    label: string;
+    /** The test ids that exist; undefined when checkFlow was not given them (no reference check) */
+    tests?: ReadonlySet<string>;
+    /** The group names that exist; undefined when checkFlow was not given them */
+    groups?: ReadonlySet<string>;
+}
+export interface Option {
+    label: string;
+    value: string;
+}
+interface FieldBase {
+    /** Where the value lives in the node: `title`, `subtitle`, `continueSession`, `config.<key>`, `ref.testId` or `ref.group` */
+    path: string;
+    label?: string;
+}
+/**
+ * One setting of a node, as data. The editor decides how to render it. The app's
+ * `custom` field type (a React component) is not part of core: the editor attaches
+ * those to a kind itself.
+ */
+export type Field = (FieldBase & {
+    type: "text";
+    placeholder?: string;
+    default?: string;
+}) | (FieldBase & {
+    type: "code";
+    placeholder?: string;
+    default?: string;
+}) | (FieldBase & {
+    type: "expression";
+    placeholder?: string;
+    default?: string;
+}) | (FieldBase & {
+    type: "number";
+    unit?: string;
+    default?: number;
+}) | (FieldBase & {
+    type: "select";
+    options: Option[];
+    default?: string;
+}) | (FieldBase & {
+    type: "segmented";
+    options: Option[];
+    default?: string;
+}) | (FieldBase & {
+    type: "switch";
+    default?: boolean;
+}) | (FieldBase & {
+    type: "test";
+}) | (FieldBase & {
+    type: "group";
+});
+/** How a run treats a node in the graph */
+export type Shape = "start" | "end" | "step" | "branches";
+/** The tones of the design system's flow chips */
+export type BranchTone = "neutral" | "success" | "warning" | "error" | "info";
+/** One named way out of a `branches` node */
+export interface Branch {
+    /** Stored as the edge's `sourceHandle` */
+    name: string;
+    /** The chip on the canvas; leave it out for no chip */
+    label?: string;
+    /** The chip's colour: a theme tone, or any CSS colour such as "#7c3aed" */
+    color?: BranchTone | (string & {});
+}
+/** Branches that come and go: filled ones plus one empty to drop onto, at least `min` in all */
+export interface DynamicBranches {
+    dynamic: true;
+    min: number;
+}
+/** The type a field's value has in `config` */
+type ValueOf<F> = F extends {
+    type: "number";
+} ? number : F extends {
+    type: "switch";
+} ? boolean : string;
+/** `config` as the definition's `config.*` fields describe it */
+export type ConfigOf<F extends readonly Field[]> = {
+    [K in F[number] as K["path"] extends `config.${infer P}` ? P : never]: ValueOf<K>;
+};
+/** A node whose `config` is typed (and filled from the field defaults) */
+export type TypedNode<C> = Omit<FlowNodeModel, "config"> & {
+    config: C;
+};
+/**
+ * The core half of a node kind: data and pure functions only. What a kind does in a
+ * run is a handler in `flows/run`; how it looks is the editor's half.
+ */
+export interface NodeCoreDefinition<K extends string = string, C = Record<string, unknown>> {
+    /** Stored in flow files as the node's `kind` */
+    kind: K;
+    /** The kind's name; messages use it */
+    label: string;
+    shape: Shape;
+    /**
+     * `branches`: a fixed list (the first is the one kept on delete), or
+     * `{ dynamic: true, min }` for a list that grows as branches are filled, named `branch-<n>`
+     */
+    branches?: readonly Branch[] | DynamicBranches;
+    fields: readonly Field[];
+    /** The node can write outputs (shared-context variables) */
+    outputs?: boolean;
+    /** A step's output names: readable later as `nodes.<key>.<name>` */
+    results?: readonly string[];
+    /** The path of the field holding the name of a variable the node writes (`vars.<name>`) */
+    writesVar?: string;
+    /** The node has an "on failure" choice */
+    onFailure?: boolean;
+    /** Pure: problems with this node alone. `node.config` has the field defaults filled in. */
+    validate?: (node: TypedNode<C>, ctx: NodeCtx) => FlowProblem[];
+}
+/** Any definition, for the registry */
+export type AnyNodeDefinition = NodeCoreDefinition<string, any>;
+/** Declares a node kind; the type of `config` comes from the `config.*` fields */
+export declare function defineNode<const K extends string, const F extends readonly Field[]>(def: Omit<NodeCoreDefinition<K, ConfigOf<F>>, "fields"> & {
+    fields: F;
+}): NodeCoreDefinition<K, ConfigOf<F>>;
+/** The values the definition's `config.*` fields start with */
+export declare function configDefaults(def: Pick<AnyNodeDefinition, "fields">): Record<string, unknown>;
+/** The node with every field default filled in, so `validate` sees typed config even for old files */
+export declare function withDefaults<C>(def: NodeCoreDefinition<string, C>, node: FlowNodeModel): TypedNode<C>;
+export {};

package/dist/flows/core/nodes/define.js

@@ -0,0 +1,21 @@
+/** Declares a node kind; the type of `config` comes from the `config.*` fields */
+export function defineNode(def) {
+    return def;
+}
+/** The values the definition's `config.*` fields start with */
+export function configDefaults(def) {
+    const config = {};
+    for (const f of def.fields)
+        if (f.path.startsWith("config.") &&
+            "default" in f &&
+            f.default !== undefined)
+            config[f.path.slice("config.".length)] = f.default;
+    return config;
+}
+/** The node with every field default filled in, so `validate` sees typed config even for old files */
+export function withDefaults(def, node) {
+    return {
+        ...node,
+        config: { ...configDefaults(def), ...node.config },
+    };
+}

package/dist/flows/core/nodes/end.d.ts

@@ -0,0 +1 @@
+export declare const end: import("./define.js").NodeCoreDefinition<"end", import("./define.js").ConfigOf<readonly []>>;

package/dist/flows/core/nodes/end.js

@@ -0,0 +1,7 @@
+import { defineNode } from "./define.js";
+export const end = defineNode({
+    kind: "end",
+    label: "End",
+    shape: "end",
+    fields: [],
+});

package/dist/flows/core/nodes/group.d.ts

@@ -0,0 +1,5 @@
+export declare const group: import("./define.js").NodeCoreDefinition<"group", import("./define.js").ConfigOf<readonly [{
+    readonly path: "ref.group";
+    readonly type: "group";
+    readonly label: "Group";
+}]>>;

package/dist/flows/core/nodes/group.js

@@ -0,0 +1,18 @@
+import { defineNode } from "./define.js";
+// The app's editor adds the `continueSession` field (a custom component) to this kind.
+export const group = defineNode({
+    kind: "group",
+    label: "Group",
+    shape: "step",
+    fields: [{ path: "ref.group", type: "group", label: "Group" }],
+    outputs: true,
+    validate: (node, ctx) => ctx.groups && !(node.ref?.group && ctx.groups.has(node.ref.group))
+        ? [
+            {
+                level: "error",
+                nodeId: node.id,
+                message: `The ${ctx.label.toLowerCase()} ${node.ref?.group ?? ""} no longer exists.`,
+            },
+        ]
+        : [],
+});

package/dist/flows/core/nodes/index.d.ts

@@ -0,0 +1,45 @@
+import type { AnyNodeDefinition, Branch, DynamicBranches } from "./define.js";
+declare const registered: readonly [import("./define.js").NodeCoreDefinition<"start", import("./define.js").ConfigOf<readonly []>>, import("./define.js").NodeCoreDefinition<"end", import("./define.js").ConfigOf<readonly []>>, import("./define.js").NodeCoreDefinition<"test", import("./define.js").ConfigOf<readonly []>>, import("./define.js").NodeCoreDefinition<"group", import("./define.js").ConfigOf<readonly [{
+    readonly path: "ref.group";
+    readonly type: "group";
+    readonly label: "Group";
+}]>>, import("./define.js").NodeCoreDefinition<"condition", import("./define.js").ConfigOf<readonly [{
+    readonly path: "config.expr";
+    readonly type: "expression";
+    readonly label: "Expression";
+    readonly placeholder: "nodes.login.status == \"passed\"";
+    readonly default: "";
+}]>>, import("./define.js").NodeCoreDefinition<"parallel", import("./define.js").ConfigOf<readonly []>>];
+export type NodeKind = (typeof registered)[number]["kind"];
+export declare const NODES: readonly AnyNodeDefinition[];
+/** The definition of a kind; throws for an unknown one */
+export declare function nodeDef(kind: string): AnyNodeDefinition;
+/** The kinds core defines itself; every other kind is a step */
+export declare const CLOSED_KINDS: readonly string[];
+/** How a run treats a node in the graph: a kind core doesn't define is a step */
+export declare const shapeOf: (node: {
+    kind: string;
+}) => import("./define.js").Shape;
+/** The branch names a dynamic list gives its branches: branch-0, branch-1, ... */
+export declare const dynamicName: (index: number) => string;
+/** The dynamic branch settings of a `branches` node; undefined for a fixed list and any other shape */
+export declare const dynamicOf: (node: {
+    kind: string;
+}) => DynamicBranches | undefined;
+/**
+ * The branches a new `branches` node starts with, in order: its fixed list, or
+ * `min` empty ones for a dynamic list. Empty for any other shape.
+ */
+export declare const branchesOf: (node: {
+    kind: string;
+}) => readonly Branch[];
+/** The branch an edge out of a `branches` node leaves by (a dynamic list has no labels or colours) */
+export declare const branchOf: (node: {
+    kind: string;
+}, handle: string | undefined) => Branch | undefined;
+/** The names of the branches `branchesOf` lists */
+export declare const branchNames: (node: {
+    kind: string;
+}) => string[];
+export * from "./define.js";
+export * from "./path.js";

package/dist/flows/core/nodes/index.js

@@ -0,0 +1,55 @@
+import { condition } from "./condition.js";
+import { end } from "./end.js";
+import { group } from "./group.js";
+import { parallel } from "./parallel.js";
+import { start } from "./start.js";
+import { test } from "./test.js";
+// Library order. Every other kind is a step (`flows/steps`).
+const registered = [start, end, test, group, condition, parallel];
+export const NODES = registered;
+/** The definition of a kind; throws for an unknown one */
+export function nodeDef(kind) {
+    const def = NODES.find((d) => d.kind === kind);
+    if (!def)
+        throw new Error(`Unknown node kind: ${kind}`);
+    return def;
+}
+/** The definition of a kind core registers; undefined for any other (a step) */
+const closedDef = (kind) => NODES.find((d) => d.kind === kind);
+/** The kinds core defines itself; every other kind is a step */
+export const CLOSED_KINDS = NODES.map((d) => d.kind);
+/** How a run treats a node in the graph: a kind core doesn't define is a step */
+export const shapeOf = (node) => closedDef(node.kind)?.shape ?? "step";
+/** The branch names a dynamic list gives its branches: branch-0, branch-1, ... */
+export const dynamicName = (index) => `branch-${index}`;
+/** The dynamic branch settings of a `branches` node; undefined for a fixed list and any other shape */
+export const dynamicOf = (node) => {
+    const def = closedDef(node.kind);
+    return def?.shape === "branches" &&
+        def.branches &&
+        !Array.isArray(def.branches)
+        ? def.branches
+        : undefined;
+};
+/**
+ * The branches a new `branches` node starts with, in order: its fixed list, or
+ * `min` empty ones for a dynamic list. Empty for any other shape.
+ */
+export const branchesOf = (node) => {
+    const def = closedDef(node.kind);
+    if (!def || def.shape !== "branches" || !def.branches)
+        return [];
+    if (Array.isArray(def.branches))
+        return def.branches;
+    return Array.from({ length: def.branches.min }, (_, i) => ({ name: dynamicName(i) }));
+};
+/** The branch an edge out of a `branches` node leaves by (a dynamic list has no labels or colours) */
+export const branchOf = (node, handle) => dynamicOf(node)
+    ? handle
+        ? { name: handle }
+        : undefined
+    : branchesOf(node).find((b) => b.name === handle);
+/** The names of the branches `branchesOf` lists */
+export const branchNames = (node) => branchesOf(node).map((b) => b.name);
+export * from "./define.js";
+export * from "./path.js";

package/dist/flows/core/nodes/parallel.d.ts

@@ -0,0 +1 @@
+export declare const parallel: import("./define.js").NodeCoreDefinition<"parallel", import("./define.js").ConfigOf<readonly []>>;

package/dist/flows/core/nodes/parallel.js

@@ -0,0 +1,11 @@
+import { defineNode } from "./define.js";
+// Every branch leads on to the node after the Parallel. Branches are dropped
+// onto one at a time: the list is always its filled branches plus one empty.
+export const parallel = defineNode({
+    kind: "parallel",
+    label: "Parallel",
+    shape: "branches",
+    branches: { dynamic: true, min: 2 },
+    fields: [],
+    onFailure: true,
+});

package/dist/flows/core/nodes/path.d.ts

@@ -0,0 +1,5 @@
+import type { FlowNodeModel } from "../schema.js";
+/** Reads a field's value from the node: `title`, `subtitle`, `continueSession`, `config.*` or `ref.*` */
+export declare function getPath(node: FlowNodeModel, path: string): unknown;
+/** The patch that writes a field's value, keeping the other keys of `config` and `ref` */
+export declare function setPath(node: FlowNodeModel, path: string, value: unknown): Partial<FlowNodeModel>;

package/dist/flows/core/nodes/path.js

@@ -0,0 +1,21 @@
+/** Splits `config.expr` into `["config", "expr"]`; `title` is a top-level key */
+function split(path) {
+    const i = path.indexOf(".");
+    return i < 0 ? [path, undefined] : [path.slice(0, i), path.slice(i + 1)];
+}
+/** Reads a field's value from the node: `title`, `subtitle`, `continueSession`, `config.*` or `ref.*` */
+export function getPath(node, path) {
+    const [head, rest] = split(path);
+    const top = node[head];
+    if (rest === undefined)
+        return top;
+    return top?.[rest];
+}
+/** The patch that writes a field's value, keeping the other keys of `config` and `ref` */
+export function setPath(node, path, value) {
+    const [head, rest] = split(path);
+    if (rest === undefined)
+        return { [head]: value };
+    const top = node[head];
+    return { [head]: { ...top, [rest]: value } };
+}

package/dist/flows/core/nodes/start.d.ts

@@ -0,0 +1 @@
+export declare const start: import("./define.js").NodeCoreDefinition<"start", import("./define.js").ConfigOf<readonly []>>;

package/dist/flows/core/nodes/start.js

@@ -0,0 +1,7 @@
+import { defineNode } from "./define.js";
+export const start = defineNode({
+    kind: "start",
+    label: "Start",
+    shape: "start",
+    fields: [],
+});

package/dist/flows/core/nodes/test.d.ts

@@ -0,0 +1 @@
+export declare const test: import("./define.js").NodeCoreDefinition<"test", import("./define.js").ConfigOf<readonly []>>;

package/dist/flows/core/nodes/test.js

@@ -0,0 +1,18 @@
+import { defineNode } from "./define.js";
+// The app's editor adds the `continueSession` field (a custom component) to this kind.
+export const test = defineNode({
+    kind: "test",
+    label: "Test",
+    shape: "step",
+    fields: [],
+    outputs: true,
+    validate: (node, ctx) => ctx.tests && !(node.ref?.testId && ctx.tests.has(node.ref.testId))
+        ? [
+            {
+                level: "error",
+                nodeId: node.id,
+                message: `A ${ctx.label.toLowerCase()} in this flow was deleted or moved.`,
+            },
+        ]
+        : [],
+});

package/dist/flows/core/schema.d.ts

@@ -0,0 +1,55 @@
+export interface FlowNodeOutput {
+    /** Name of the shared-context variable the node writes */
+    name: string;
+}
+export interface FlowNodeModel {
+    id: string;
+    /** Short name expressions use: nodes.<key>. Lowercase letters, digits and _, unique in the flow */
+    key?: string;
+    /** A registered node kind (see the renderer's node definitions) */
+    kind: string;
+    title?: string;
+    subtitle?: string;
+    /** test: the project test id (file::name). group: the group name */
+    ref?: {
+        testId?: string;
+        group?: string;
+    };
+    outputs?: FlowNodeOutput[];
+    /** What to do when the node fails; "stop" ends the run there */
+    onFailure: "stop" | "continue";
+    /** Continue in the previous node's browser session (kept in the file; the framework opens a fresh browser per test today) */
+    continueSession?: boolean;
+    /** Per-kind settings, named by each definition's `config.*` fields*/
+    config?: Record<string, unknown>;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export interface FlowEdgeModel {
+    id: string;
+    source: string;
+    target: string;
+    /** The named branch of a node with branches (a condition's "true" or "false", a parallel's "branch-0") */
+    sourceHandle?: string;
+}
+/** One flow, as stored in <project>/flows/<id>.flow.json */
+export interface FlowFile {
+    id: string;
+    /** The file format version; a missing one means 1. See readFlowFile */
+    version?: number;
+    name: string;
+    description?: string;
+    /** The environment the flow runs in; the header's selection otherwise */
+    envDefault?: string;
+    nodes: FlowNodeModel[];
+    edges: FlowEdgeModel[];
+}
+/** The flow file format version this framework writes and reads */
+export declare const FLOW_VERSION = 1;
+/**
+ * Read a parsed flow file (JSON.parse output) into a FlowFile.
+ * A missing `version` is 1; older files are migrated; a file from a newer SAMURAI throws.
+ */
+export declare function readFlowFile(raw: unknown): FlowFile;

package/dist/flows/core/schema.js

@@ -0,0 +1,33 @@
+/** The flow file format version this framework writes and reads */
+export const FLOW_VERSION = 1;
+/** Steps, in order, that lift an older file to FLOW_VERSION. Empty while version 1 is the only one. */
+const MIGRATIONS = [];
+/**
+ * Read a parsed flow file (JSON.parse output) into a FlowFile.
+ * A missing `version` is 1; older files are migrated; a file from a newer SAMURAI throws.
+ */
+export function readFlowFile(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("A flow file must be a JSON object.");
+    }
+    let flow = raw;
+    const version = flow.version === undefined ? 1 : flow.version;
+    if (typeof version !== "number" ||
+        !Number.isInteger(version) ||
+        version < 1) {
+        throw new Error("The flow file's version must be a positive whole number.");
+    }
+    if (version > FLOW_VERSION) {
+        throw new Error("This flow was saved by a newer SAMURAI. Update @itmetsam/samurai-framework.");
+    }
+    if (!Array.isArray(flow.nodes))
+        throw new Error("A flow file needs a nodes array.");
+    if (!Array.isArray(flow.edges))
+        throw new Error("A flow file needs an edges array.");
+    for (let at = version; at < FLOW_VERSION; at++) {
+        const step = MIGRATIONS.find((m) => m.from === at);
+        if (step)
+            flow = step.migrate(flow);
+    }
+    return { ...flow, version: FLOW_VERSION };
+}

package/dist/flows/core/steps.d.ts

@@ -0,0 +1,42 @@
+import type { Field, FlowProblem, NodeCoreDefinition } from "./nodes/define.js";
+import type { FlowNodeModel } from "./schema.js";
+/** Rules a step field carries: checked live in the builder and again by checkFlow */
+export interface FieldRules {
+    required?: boolean;
+    /** `number` fields */
+    min?: number;
+    max?: number;
+    /** `text` fields: a regular expression the value must match */
+    pattern?: string;
+    /** Said instead of the default when `pattern` doesn't match */
+    patternMessage?: string;
+}
+export type StepField = Field & FieldRules;
+export type StepSection = "control" | "integrations";
+export interface StepOutput {
+    name: string;
+    label?: string;
+}
+/** A step as data: what the app's catalog holds. No functions. */
+export interface StepInfo {
+    /** Stored in flow files as the node's `kind` */
+    kind: string;
+    label: string;
+    /** A design-system icon name */
+    icon: string;
+    section: StepSection;
+    /** `config.*` fields; Title and Description are added by `stepNodeOf` */
+    fields: readonly StepField[];
+    /** The line under the title: `{config.x}` is replaced with the field's value */
+    summary?: string;
+    outputs?: readonly StepOutput[];
+    /** The path of the field holding a variable name the step writes */
+    writesVar?: string;
+}
+export declare const STEP_KIND: RegExp;
+/** A node's own result fields: an output can't take these names */
+export declare const RESERVED_OUTPUTS: readonly string[];
+/** Problems with `node`'s values against the fields' rules, as "Label: message" */
+export declare function fieldProblems(fields: readonly StepField[], node: FlowNodeModel, label: string): FlowProblem[];
+/** The definition core's walker and checkFlow use for a step; `validate` is the step's own (engine only) */
+export declare function stepNodeOf(info: StepInfo, validate?: NodeCoreDefinition["validate"]): NodeCoreDefinition;

package/dist/flows/core/steps.js

@@ -0,0 +1,47 @@
+import { getPath } from "./nodes/path.js";
+export const STEP_KIND = /^[a-z][a-z0-9-]*$/;
+/** A node's own result fields: an output can't take these names */
+export const RESERVED_OUTPUTS = ["status", "durationMs", "error"];
+const TITLE_FIELDS = [
+    { path: "title", type: "text", label: "Title" },
+    { path: "subtitle", type: "text", label: "Description" },
+];
+const empty = (value) => value === undefined || (typeof value === "string" && value.trim() === "");
+/** Problems with `node`'s values against the fields' rules, as "Label: message" */
+export function fieldProblems(fields, node, label) {
+    const problems = [];
+    const add = (message) => problems.push({ level: "error", nodeId: node.id, message: `${label}: ${message}` });
+    for (const f of fields) {
+        const name = f.label ?? f.path;
+        const value = getPath(node, f.path);
+        if (f.required && empty(value)) {
+            add(`${name} is required.`);
+            continue;
+        }
+        if (typeof value === "number") {
+            if (f.min !== undefined && value < f.min)
+                add(`${name} must be at least ${f.min}.`);
+            if (f.max !== undefined && value > f.max)
+                add(`${name} must be at most ${f.max}.`);
+        }
+        if (f.pattern && typeof value === "string" && value !== "" && !new RegExp(f.pattern).test(value))
+            add(f.patternMessage ?? `${name} doesn't match ${f.pattern}.`);
+    }
+    return problems;
+}
+/** The definition core's walker and checkFlow use for a step; `validate` is the step's own (engine only) */
+export function stepNodeOf(info, validate) {
+    return {
+        kind: info.kind,
+        label: info.label,
+        shape: "step",
+        fields: [...TITLE_FIELDS, ...info.fields],
+        onFailure: true,
+        results: (info.outputs ?? []).map((o) => o.name),
+        ...(info.writesVar !== undefined && { writesVar: info.writesVar }),
+        validate: (node, ctx) => [
+            ...fieldProblems(info.fields, node, ctx.label),
+            ...(validate?.(node, ctx) ?? []),
+        ],
+    };
+}

package/dist/flows/run/events.d.ts

@@ -0,0 +1,45 @@
+import type { RunEvent } from "../../runner/reporter.js";
+export type NodeStatus = "passed" | "failed" | "skipped" | "not-run";
+export interface NodeResult {
+    status: NodeStatus;
+    durationMs?: number;
+    error?: string;
+    /** Why it was skipped, e.g. "Not supported yet" */
+    note?: string;
+    /** Condition: the branch taken */
+    branch?: string;
+    /** What the node wrote to vars */
+    wrote?: Record<string, unknown>;
+    /** A step's outputs, readable later as `nodes.<key>.<name>` */
+    outputs?: Record<string, unknown>;
+}
+/** One test of a node: absolute file and full name */
+export interface NodeTest {
+    file: string;
+    name: string;
+}
+export type FlowEvent = {
+    type: "flow-start";
+    environment: string;
+} | {
+    type: "node-start";
+    nodeId: string;
+} | {
+    type: "node-end";
+    nodeId: string;
+    result: NodeResult;
+} | {
+    type: "test";
+    nodeId: string;
+    event: RunEvent;
+} | {
+    type: "flow-end";
+    summary: FlowSummary;
+};
+export interface FlowSummary {
+    status: "passed" | "failed" | "cancelled";
+    nodes: Record<string, NodeResult>;
+    vars: Record<string, unknown>;
+    /** The flow couldn't be walked at all */
+    error?: string;
+}

package/dist/flows/run/events.js

@@ -0,0 +1 @@
+export {};

package/dist/flows/run/files.d.ts

@@ -0,0 +1,12 @@
+import { type FlowFile } from "../core/index.js";
+export declare const FLOW_SUFFIX = ".flow.json";
+/** The folder a project keeps its flows in */
+export declare const flowsDir: (projectDir: string) => string;
+/** The ids of the project's flows (file name without `.flow.json`), sorted. Other files are ignored; no folder means no flows. */
+export declare function listFlows(projectDir: string): Promise<string[]>;
+/** Reads `<project>/flows/<id>.flow.json`; the flow's `id` is the file name, whatever the file says */
+export declare function readFlow(projectDir: string, id: string): Promise<FlowFile>;
+/** Reads a `.flow.json` file by its path; the flow's `id` is `id`, else the file name without the suffix */
+export declare function readFlowPath(file: string, id?: string): Promise<FlowFile>;
+/** Reads every flow of the project, in id order; one that can't be read throws */
+export declare function readFlows(projectDir: string): Promise<FlowFile[]>;