@nocobase/flow-engine 2.0.0-alpha.10

package/lib/FlowDefinition.d.ts

@@ -0,0 +1,423 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowDefinitionOptions, StepDefinition } from './types';
+import { IFlowRepository } from './flow-registry/BaseFlowRegistry';
+export declare class FlowDefinition {
+    protected flowRegistry: IFlowRepository;
+    _steps: Map<string, FlowStep>;
+    protected options: Omit<FlowDefinitionOptions, 'steps'>;
+    constructor(options: FlowDefinitionOptions, flowRegistry: IFlowRepository);
+    get key(): string;
+    get title(): string;
+    set title(title: string);
+    get sort(): number;
+    get on(): import("./types").FlowEvent<import(".").FlowModel<import("./types").DefaultStructure>>;
+    set on(on: import("./types").FlowEvent<import(".").FlowModel<import("./types").DefaultStructure>>);
+    get defaultParams(): Record<string, any> | ((ctx: import("./flowContext").FlowModelContext) => {
+        [stepKey: string]: {
+            [paramKey: string]: any;
+        };
+    } | Promise<{
+        [stepKey: string]: {
+            [paramKey: string]: any;
+        };
+    }>);
+    get manual(): boolean;
+    set manual(manual: boolean);
+    get steps(): Record<string, StepDefinition<import(".").FlowModel<import("./types").DefaultStructure>>>;
+    getSortedSteps(): [string, FlowStep][];
+    setOptions(flowOptions: Omit<FlowDefinitionOptions, 'key' | 'steps'>): void;
+    getSteps(): Map<string, FlowStep>;
+    mapSteps(callback: (step: FlowStep) => any): any[];
+    getStep(stepKey: string): FlowStep;
+    addStep(stepKey: string, flowStep: Omit<StepDefinition, 'key'>): FlowStep;
+    setStep(stepKey: string, flowStep: StepDefinition): FlowStep;
+    hasStep(stepKey: string): boolean;
+    moveStep(sourceStepKey: string, targetStepKey: string): void;
+    removeStep(stepKey: string): void;
+    saveStep(step: FlowStep): Promise<void>;
+    destroyStep(stepKey: string): Promise<void>;
+    save(): Promise<void>;
+    destroy(): Promise<void>;
+    remove(): void;
+    toData(): any;
+    serialize(): any;
+}
+export declare class FlowStep {
+    protected flowDef: FlowDefinition;
+    protected options: StepDefinition;
+    constructor(options: StepDefinition, flowDef: FlowDefinition);
+    setOptions(stepOptions: Omit<StepDefinition, 'key' | 'flowKey'>): void;
+    get key(): string;
+    get flowKey(): string;
+    get title(): string;
+    set title(title: string);
+    get uiSchema(): Record<string, import("@formily/json-schema").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@formily/json-schema").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@formily/json-schema").SchemaTypes;
+        enum?: import("@formily/json-schema").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string | boolean | string[];
+        format?: string;
+        $ref?: string;
+        $namespace?: string;
+        definitions?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@formily/json-schema").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@formily/json-schema").Stringify<any>;
+        patternProperties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@formily/json-schema").Stringify<any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/json-schema").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>> | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => Record<string, import("@formily/json-schema").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@formily/json-schema").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@formily/json-schema").SchemaTypes;
+        enum?: import("@formily/json-schema").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string | boolean | string[];
+        format?: string;
+        $ref?: string;
+        $namespace?: string;
+        definitions?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@formily/json-schema").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@formily/json-schema").Stringify<any>;
+        patternProperties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@formily/json-schema").Stringify<any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/json-schema").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>> | Promise<Record<string, import("@formily/json-schema").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@formily/json-schema").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@formily/json-schema").SchemaTypes;
+        enum?: import("@formily/json-schema").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string | boolean | string[];
+        format?: string;
+        $ref?: string;
+        $namespace?: string;
+        definitions?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@formily/json-schema").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@formily/json-schema").Stringify<any>;
+        patternProperties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@formily/json-schema").Stringify<any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/json-schema").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>>>);
+    get defaultParams(): Record<string, any>;
+    set defaultParams(params: Record<string, any>);
+    get use(): string;
+    save(): Promise<void>;
+    remove(): Promise<void>;
+    destroy(): Promise<void>;
+    serialize(): {
+        flowKey: string;
+        key?: string;
+        isAwait?: boolean;
+        use?: string;
+        sort?: number;
+        preset?: boolean;
+        paramsRequired?: boolean;
+        hideInSettings?: boolean;
+        uiMode?: import("./types").StepUIMode | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => import("./types").StepUIMode | Promise<import("./types").StepUIMode>);
+        title?: string;
+        defaultParams?: Record<string, any> | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => Record<string, any> | Promise<Record<string, any>>);
+        handler?: (ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>, params: any) => any;
+        uiSchema?: Record<string, import("@formily/json-schema").Stringify<{
+            [key: symbol]: any;
+            [key: `x-${string}`]: any;
+            [key: `x-${number}`]: any;
+            version?: string;
+            name?: import("@formily/json-schema").SchemaKey;
+            title?: any;
+            description?: any;
+            default?: any;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            type?: import("@formily/json-schema").SchemaTypes;
+            enum?: import("@formily/json-schema").SchemaEnum<any>;
+            const?: any;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: number;
+            minimum?: number;
+            exclusiveMinimum?: number;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string | RegExp;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string | boolean | string[];
+            format?: string;
+            $ref?: string;
+            $namespace?: string;
+            definitions?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            properties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            items?: import("@formily/json-schema").SchemaItems<any, any, any, any, any, any, any, any>;
+            additionalItems?: import("@formily/json-schema").Stringify<any>;
+            patternProperties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            additionalProperties?: import("@formily/json-schema").Stringify<any>;
+            "x-value"?: any;
+            "x-index"?: number;
+            "x-pattern"?: any;
+            "x-display"?: any;
+            "x-validator"?: any;
+            "x-decorator"?: any;
+            "x-decorator-props"?: any;
+            "x-component"?: any;
+            "x-component-props"?: any;
+            "x-reactions"?: import("@formily/json-schema").SchemaReactions<any>;
+            "x-content"?: any;
+            "x-data"?: any;
+            "x-visible"?: boolean;
+            "x-hidden"?: boolean;
+            "x-disabled"?: boolean;
+            "x-editable"?: boolean;
+            "x-read-only"?: boolean;
+            "x-read-pretty"?: boolean;
+            "x-compile-omitted"?: string[];
+        }>> | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => Record<string, import("@formily/json-schema").Stringify<{
+            [key: symbol]: any;
+            [key: `x-${string}`]: any;
+            [key: `x-${number}`]: any;
+            version?: string;
+            name?: import("@formily/json-schema").SchemaKey;
+            title?: any;
+            description?: any;
+            default?: any;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            type?: import("@formily/json-schema").SchemaTypes;
+            enum?: import("@formily/json-schema").SchemaEnum<any>;
+            const?: any;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: number;
+            minimum?: number;
+            exclusiveMinimum?: number;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string | RegExp;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string | boolean | string[];
+            format?: string;
+            $ref?: string;
+            $namespace?: string;
+            definitions?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            properties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            items?: import("@formily/json-schema").SchemaItems<any, any, any, any, any, any, any, any>;
+            additionalItems?: import("@formily/json-schema").Stringify<any>;
+            patternProperties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            additionalProperties?: import("@formily/json-schema").Stringify<any>;
+            "x-value"?: any;
+            "x-index"?: number;
+            "x-pattern"?: any;
+            "x-display"?: any;
+            "x-validator"?: any;
+            "x-decorator"?: any;
+            "x-decorator-props"?: any;
+            "x-component"?: any;
+            "x-component-props"?: any;
+            "x-reactions"?: import("@formily/json-schema").SchemaReactions<any>;
+            "x-content"?: any;
+            "x-data"?: any;
+            "x-visible"?: boolean;
+            "x-hidden"?: boolean;
+            "x-disabled"?: boolean;
+            "x-editable"?: boolean;
+            "x-read-only"?: boolean;
+            "x-read-pretty"?: boolean;
+            "x-compile-omitted"?: string[];
+        }>> | Promise<Record<string, import("@formily/json-schema").Stringify<{
+            [key: symbol]: any;
+            [key: `x-${string}`]: any;
+            [key: `x-${number}`]: any;
+            version?: string;
+            name?: import("@formily/json-schema").SchemaKey;
+            title?: any;
+            description?: any;
+            default?: any;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            type?: import("@formily/json-schema").SchemaTypes;
+            enum?: import("@formily/json-schema").SchemaEnum<any>;
+            const?: any;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: number;
+            minimum?: number;
+            exclusiveMinimum?: number;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string | RegExp;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string | boolean | string[];
+            format?: string;
+            $ref?: string;
+            $namespace?: string;
+            definitions?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            properties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            items?: import("@formily/json-schema").SchemaItems<any, any, any, any, any, any, any, any>;
+            additionalItems?: import("@formily/json-schema").Stringify<any>;
+            patternProperties?: import("@formily/json-schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+            additionalProperties?: import("@formily/json-schema").Stringify<any>;
+            "x-value"?: any;
+            "x-index"?: number;
+            "x-pattern"?: any;
+            "x-display"?: any;
+            "x-validator"?: any;
+            "x-decorator"?: any;
+            "x-decorator-props"?: any;
+            "x-component"?: any;
+            "x-component-props"?: any;
+            "x-reactions"?: import("@formily/json-schema").SchemaReactions<any>;
+            "x-content"?: any;
+            "x-data"?: any;
+            "x-visible"?: boolean;
+            "x-hidden"?: boolean;
+            "x-disabled"?: boolean;
+            "x-editable"?: boolean;
+            "x-read-only"?: boolean;
+            "x-read-pretty"?: boolean;
+            "x-compile-omitted"?: string[];
+        }>>>);
+        beforeParamsSave?: (ctx: import("./flowContext").FlowSettingsContext<import(".").FlowModel<import("./types").DefaultStructure>>, params: any, previousParams: any) => void | Promise<void>;
+        afterParamsSave?: (ctx: import("./flowContext").FlowSettingsContext<import(".").FlowModel<import("./types").DefaultStructure>>, params: any, previousParams: any) => void | Promise<void>;
+        useRawParams?: boolean | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => boolean | Promise<boolean>);
+        scene?: import("./types").ActionScene | import("./types").ActionScene[];
+    };
+}

package/lib/FlowDefinition.js

@@ -0,0 +1,257 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FlowDefinition_exports = {};
+__export(FlowDefinition_exports, {
+  FlowDefinition: () => FlowDefinition,
+  FlowStep: () => FlowStep
+});
+module.exports = __toCommonJS(FlowDefinition_exports);
+var import_reactive = require("@formily/reactive");
+var import_lodash = __toESM(require("lodash"));
+const _FlowDefinition = class _FlowDefinition {
+  constructor(options, flowRegistry) {
+    this.flowRegistry = flowRegistry;
+    this.options = import_reactive.observable.shallow(import_lodash.default.omit(options, ["steps"]));
+    for (const [stepKey, step] of Object.entries(options.steps || {})) {
+      this.addStep(stepKey, step);
+    }
+  }
+  _steps = import_reactive.observable.shallow(/* @__PURE__ */ new Map());
+  options;
+  get key() {
+    return this.options.key;
+  }
+  get title() {
+    return this.options.title;
+  }
+  set title(title) {
+    this.options.title = title;
+  }
+  get sort() {
+    return this.options.sort;
+  }
+  get on() {
+    return this.options.on;
+  }
+  set on(on) {
+    this.options.on = on;
+  }
+  get defaultParams() {
+    return this.options.defaultParams;
+  }
+  get manual() {
+    return this.options.manual;
+  }
+  set manual(manual) {
+    this.options.manual = manual;
+  }
+  get steps() {
+    const steps = {};
+    const sortedSteps = this.getSortedSteps();
+    for (const [stepKey, step] of sortedSteps) {
+      steps[stepKey] = step.serialize();
+    }
+    return steps;
+  }
+  getSortedSteps() {
+    return [...this._steps.entries()].sort(([, stepA], [, stepB]) => {
+      const sortA = stepA.serialize().sort ?? 0;
+      const sortB = stepB.serialize().sort ?? 0;
+      return sortA - sortB;
+    });
+  }
+  setOptions(flowOptions) {
+    Object.assign(this.options, flowOptions);
+  }
+  getSteps() {
+    return this._steps;
+  }
+  mapSteps(callback) {
+    const sortedSteps = this.getSortedSteps();
+    return sortedSteps.map(([, step]) => {
+      return callback(step);
+    });
+  }
+  getStep(stepKey) {
+    return this._steps.get(stepKey);
+  }
+  addStep(stepKey, flowStep) {
+    const existingStep = this._steps.get(stepKey);
+    if (existingStep) {
+      existingStep.setOptions(flowStep);
+      return existingStep;
+    } else {
+      if (flowStep.sort === void 0) {
+        const maxSort = Math.max(0, ...Array.from(this._steps.values()).map((step) => step.serialize().sort ?? 0));
+        flowStep = { ...flowStep, sort: maxSort + 1 };
+      }
+      const newStep = new FlowStep(
+        {
+          ...flowStep,
+          key: stepKey
+        },
+        this
+      );
+      this._steps.set(stepKey, newStep);
+      return newStep;
+    }
+  }
+  setStep(stepKey, flowStep) {
+    return this.addStep(stepKey, flowStep);
+  }
+  hasStep(stepKey) {
+    return this._steps.has(stepKey);
+  }
+  moveStep(sourceStepKey, targetStepKey) {
+    if (!this._steps.has(sourceStepKey)) {
+      throw new Error(`Source step '${sourceStepKey}' not found`);
+    }
+    if (!this._steps.has(targetStepKey)) {
+      throw new Error(`Target step '${targetStepKey}' not found`);
+    }
+    if (sourceStepKey === targetStepKey) {
+      return;
+    }
+    const sortedSteps = this.getSortedSteps();
+    const newOrder = [];
+    const filteredSteps = sortedSteps.filter(([key]) => key !== sourceStepKey);
+    const sourceStep = this._steps.get(sourceStepKey);
+    for (const [stepKey, step] of filteredSteps) {
+      if (stepKey === targetStepKey) {
+        newOrder.push([sourceStepKey, sourceStep]);
+      }
+      newOrder.push([stepKey, step]);
+    }
+    newOrder.forEach(([stepKey, step], index) => {
+      step.setOptions({ sort: index + 1 });
+    });
+  }
+  removeStep(stepKey) {
+    this._steps.delete(stepKey);
+  }
+  async saveStep(step) {
+    await this.flowRegistry.saveFlow(this);
+  }
+  async destroyStep(stepKey) {
+    this.removeStep(stepKey);
+    await this.flowRegistry.saveFlow(this);
+  }
+  async save() {
+    await this.flowRegistry.saveFlow(this);
+  }
+  async destroy() {
+    await this.flowRegistry.destroyFlow(this.key);
+  }
+  remove() {
+    return this.flowRegistry.removeFlow(this.key);
+  }
+  toData() {
+    return this.serialize();
+  }
+  serialize() {
+    const data = {
+      ...this.options
+    };
+    const sortedSteps = this.getSortedSteps();
+    for (const [stepKey, step] of sortedSteps) {
+      data.steps = data.steps || {};
+      data.steps[stepKey] = {
+        ...step.serialize()
+      };
+    }
+    return data;
+  }
+};
+__name(_FlowDefinition, "FlowDefinition");
+let FlowDefinition = _FlowDefinition;
+const _FlowStep = class _FlowStep {
+  constructor(options, flowDef) {
+    this.flowDef = flowDef;
+    this.options = import_reactive.observable.shallow(options);
+  }
+  options;
+  setOptions(stepOptions) {
+    Object.assign(this.options, stepOptions);
+  }
+  get key() {
+    return this.options.key;
+  }
+  get flowKey() {
+    return this.flowDef.key;
+  }
+  get title() {
+    return this.options.title;
+  }
+  set title(title) {
+    this.options.title = title;
+  }
+  get uiSchema() {
+    return this.options.uiSchema;
+  }
+  get defaultParams() {
+    return this.options.defaultParams || {};
+  }
+  set defaultParams(params) {
+    this.options.defaultParams = params;
+  }
+  get use() {
+    return this.options.use;
+  }
+  async save() {
+    return this.flowDef.save();
+  }
+  async remove() {
+    return this.flowDef.removeStep(this.key);
+  }
+  async destroy() {
+    return this.flowDef.destroyStep(this.key);
+  }
+  serialize() {
+    return {
+      ...this.options,
+      flowKey: this.flowDef.key
+    };
+  }
+};
+__name(_FlowStep, "FlowStep");
+let FlowStep = _FlowStep;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowDefinition,
+  FlowStep
+});