@tachybase/module-workflow 0.23.8

package/dist/server/features/delay/Plugin.js

@@ -0,0 +1,45 @@
+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 __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 Plugin_exports = {};
+__export(Plugin_exports, {
+  PluginDelay: () => PluginDelay
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_DelayInstruction = __toESM(require("./DelayInstruction"));
+class PluginDelay extends import_server.Plugin {
+  async load() {
+    const workflowPlugin = this.app.getPlugin(import__.default);
+    workflowPlugin.registerInstruction("delay", import_DelayInstruction.default);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginDelay
+});

package/dist/server/features/dynamic-calculation/DynamicCalculation.d.ts

@@ -0,0 +1,10 @@
+import { FlowNodeModel, Instruction, Processor } from '../..';
+export declare class DynamicCalculation extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<{
+        result: any;
+        status: 1;
+    } | {
+        result: any;
+        status: -2;
+    }>;
+}

package/dist/server/features/dynamic-calculation/DynamicCalculation.js

@@ -0,0 +1,62 @@
+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 __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 DynamicCalculation_exports = {};
+__export(DynamicCalculation_exports, {
+  DynamicCalculation: () => DynamicCalculation
+});
+module.exports = __toCommonJS(DynamicCalculation_exports);
+var import_evaluators = __toESM(require("@tachybase/evaluators"));
+var import_utils = require("@tachybase/utils");
+var import__ = require("../..");
+class DynamicCalculation extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    let { engine = "math.js", expression = "" } = node.config;
+    let scope = processor.getScope(node.id);
+    const parsed = (0, import_utils.parse)(expression)(scope) ?? {};
+    engine = parsed.engine;
+    expression = parsed.expression;
+    scope = (0, import_utils.parse)(node.config.scope ?? "")(scope) ?? {};
+    const evaluator = import_evaluators.default.get(engine);
+    try {
+      const result = evaluator && expression ? evaluator(expression, scope) : null;
+      return {
+        result,
+        status: import__.JOB_STATUS.RESOLVED
+      };
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: import__.JOB_STATUS.ERROR
+      };
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamicCalculation
+});

package/dist/server/features/dynamic-calculation/Plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginDynamicCalculation extends Plugin {
+    load(): Promise<void>;
+}

package/dist/server/features/dynamic-calculation/Plugin.js

@@ -0,0 +1,49 @@
+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 __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 Plugin_exports = {};
+__export(Plugin_exports, {
+  PluginDynamicCalculation: () => PluginDynamicCalculation
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_DynamicCalculation = require("./DynamicCalculation");
+var import_expression_field = require("./expression-field");
+class PluginDynamicCalculation extends import_server.Plugin {
+  async load() {
+    this.db.registerFieldTypes({
+      expression: import_expression_field.ExpressionField
+    });
+    const workflowPlugin = this.app.getPlugin(import__.default);
+    workflowPlugin.registerInstruction("dynamic-calculation", import_DynamicCalculation.DynamicCalculation);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginDynamicCalculation
+});

package/dist/server/features/dynamic-calculation/expression-field.d.ts

@@ -0,0 +1,7 @@
+import { BaseFieldOptions, DataTypes, Field } from '@tachybase/database';
+export interface ExpressionFieldOptions extends BaseFieldOptions {
+    type: 'expression';
+}
+export declare class ExpressionField extends Field {
+    get dataType(): DataTypes.TextDataTypeConstructor;
+}

package/dist/server/features/dynamic-calculation/expression-field.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expression_field_exports = {};
+__export(expression_field_exports, {
+  ExpressionField: () => ExpressionField
+});
+module.exports = __toCommonJS(expression_field_exports);
+var import_database = require("@tachybase/database");
+class ExpressionField extends import_database.Field {
+  get dataType() {
+    return import_database.DataTypes.TEXT;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExpressionField
+});

package/dist/server/features/interception/RequestInterceptionTrigger.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Next } from '@tachybase/actions';
+import PluginWorkflowServer from '../../Plugin';
+import Trigger from '../../triggers';
+export declare class RequestInterceptionTrigger extends Trigger {
+    static TYPE: string;
+    sync: boolean;
+    middleware: (context: Context, next: Next) => Promise<never>;
+    constructor(workflow: PluginWorkflowServer);
+    on(): void;
+    off(): void;
+}

package/dist/server/features/interception/RequestInterceptionTrigger.js

@@ -0,0 +1,146 @@
+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 __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 RequestInterceptionTrigger_exports = {};
+__export(RequestInterceptionTrigger_exports, {
+  RequestInterceptionTrigger: () => RequestInterceptionTrigger
+});
+module.exports = __toCommonJS(RequestInterceptionTrigger_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_module_error_handler = __toESM(require("@tachybase/module-error-handler"));
+var import_constants = require("../../constants");
+var import_triggers = __toESM(require("../../triggers"));
+class RequestInterceptionError extends Error {
+  status = 400;
+  messages = [];
+  constructor(message) {
+    super(message);
+    this.name = "RequestInterceptionError";
+  }
+}
+class RequestInterceptionTrigger extends import_triggers.default {
+  static TYPE = "request-interception";
+  sync = true;
+  middleware = async (context, next) => {
+    const {
+      resourceName,
+      actionName,
+      params: { filterByTk, filter, values, triggerWorkflows = "" }
+    } = context.action;
+    const dataSourceHeader = context.get("x-data-source");
+    const jointCollectionName = (0, import_data_source.joinCollectionName)(dataSourceHeader, resourceName);
+    const triggerWorkflowsMap = /* @__PURE__ */ new Map();
+    const triggerWorkflowsArray = [];
+    for (const trigger of triggerWorkflows.split(",")) {
+      const [key, path] = trigger.split("!");
+      triggerWorkflowsMap.set(key, path);
+      triggerWorkflowsArray.push(key);
+    }
+    const workflows = Array.from(this.workflow.enabledCache.values()).filter(
+      (item) => item.type === RequestInterceptionTrigger.TYPE && item.config.collection === jointCollectionName
+    );
+    const globalWorkflows = workflows.filter((item) => {
+      var _a;
+      return item.config.global && ((_a = item.config.actions) == null ? void 0 : _a.includes(actionName));
+    }).sort((a, b) => a.id - b.id);
+    const localWorkflows = workflows.filter((item) => !item.config.global).sort((a, b) => {
+      const aIndex = triggerWorkflowsArray.indexOf(a.key);
+      const bIndex = triggerWorkflowsArray.indexOf(b.key);
+      if (aIndex === -1 && bIndex === -1) {
+        return a.id - b.id;
+      }
+      if (aIndex === -1) {
+        return 1;
+      }
+      if (bIndex === -1) {
+        return -1;
+      }
+      return aIndex - bIndex;
+    });
+    for (const workflow of localWorkflows.concat(globalWorkflows)) {
+      if (!workflow.config.global && !triggerWorkflowsMap.has(workflow.key)) {
+        continue;
+      }
+      const processor = await this.workflow.trigger(
+        workflow,
+        {
+          user: context.state.currentUser,
+          roleName: context.state.currentRole,
+          params: {
+            filterByTk,
+            filter,
+            values
+          }
+        },
+        { httpContext: context }
+      );
+      if (!processor) {
+        return context.throw(500);
+      }
+      const { lastSavedJob, nodesMap } = processor;
+      const lastNode = nodesMap.get(lastSavedJob == null ? void 0 : lastSavedJob.nodeId);
+      if (processor.execution.status === import_constants.EXECUTION_STATUS.RESOLVED) {
+        if ((lastNode == null ? void 0 : lastNode.type) === "end") {
+          return;
+        }
+        continue;
+      }
+      if (processor.execution.status < import_constants.EXECUTION_STATUS.STARTED) {
+        if ((lastNode == null ? void 0 : lastNode.type) !== "end") {
+          return context.throw(500, "Workflow on your action failed, please contact the administrator");
+        }
+        const err = new RequestInterceptionError("Request is intercepted by workflow");
+        err.status = 400;
+        err.messages = context.state.messages;
+        return context.throw(err.status, err);
+      }
+      return context.throw(500, "Workflow on your action hangs, please contact the administrator");
+    }
+    await next();
+  };
+  constructor(workflow) {
+    super(workflow);
+    workflow.app.use(this.middleware, { tag: "workflowFilter", after: "dataSource" });
+    workflow.app.pm.get(import_module_error_handler.default).errorHandler.register(
+      (err) => err instanceof RequestInterceptionError,
+      async (err, ctx) => {
+        ctx.body = {
+          errors: err.messages
+        };
+        ctx.status = err.status;
+      }
+    );
+  }
+  on() {
+  }
+  off() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestInterceptionTrigger
+});

package/dist/server/features/interception/index.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginInterception extends Plugin {
+    load(): Promise<void>;
+}

package/dist/server/features/interception/index.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interception_exports = {};
+__export(interception_exports, {
+  PluginInterception: () => PluginInterception
+});
+module.exports = __toCommonJS(interception_exports);
+var import_server = require("@tachybase/server");
+var import__ = require("../..");
+var import_RequestInterceptionTrigger = require("./RequestInterceptionTrigger");
+class PluginInterception extends import_server.Plugin {
+  async load() {
+    const workflowPlugin = this.app.pm.get(import__.PluginWorkflow);
+    workflowPlugin.registerTrigger("request-interception", import_RequestInterceptionTrigger.RequestInterceptionTrigger);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginInterception
+});

package/dist/server/features/loop/LoopInstruction.d.ts

@@ -0,0 +1,13 @@
+import { FlowNodeModel, Instruction, JobModel, Processor } from '../..';
+export default class extends Instruction {
+    run(node: FlowNodeModel, prevJob: JobModel, processor: Processor): Promise<{
+        status: 1;
+        result: number;
+    }>;
+    resume(node: FlowNodeModel, branchJob: any, processor: Processor): Promise<any>;
+    getScope(node: any, index: any, processor: any): {
+        item: any;
+        index: any;
+        length: number;
+    };
+}

package/dist/server/features/loop/LoopInstruction.js

@@ -0,0 +1,100 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LoopInstruction_exports = {};
+__export(LoopInstruction_exports, {
+  default: () => LoopInstruction_default
+});
+module.exports = __toCommonJS(LoopInstruction_exports);
+var import__ = require("../..");
+function getTargetLength(target) {
+  let length = 0;
+  if (typeof target === "number") {
+    if (target < 0) {
+      throw new Error("Loop target in number type must be greater than 0");
+    }
+    length = Math.floor(target);
+  } else {
+    const targets = (Array.isArray(target) ? target : [target]).filter((t) => t != null);
+    length = targets.length;
+  }
+  return length;
+}
+class LoopInstruction_default extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    const [branch] = processor.getBranches(node);
+    const target = processor.getParsedValue(node.config.target, node.id);
+    const length = getTargetLength(target);
+    if (!branch || !length) {
+      return {
+        status: import__.JOB_STATUS.RESOLVED,
+        result: 0
+      };
+    }
+    const job = await processor.saveJob({
+      status: import__.JOB_STATUS.PENDING,
+      // save loop index
+      result: 0,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    await processor.run(branch, job);
+    return null;
+  }
+  async resume(node, branchJob, processor) {
+    const job = processor.findBranchParentJob(branchJob, node);
+    const loop = processor.nodesMap.get(job.nodeId);
+    const [branch] = processor.getBranches(node);
+    const { result, status } = job;
+    if (status !== import__.JOB_STATUS.PENDING) {
+      return processor.exit();
+    }
+    const nextIndex = result + 1;
+    const target = processor.getParsedValue(loop.config.target, node.id);
+    if (branchJob.status > import__.JOB_STATUS.PENDING) {
+      job.set({ result: nextIndex });
+      const length = getTargetLength(target);
+      if (nextIndex < length) {
+        await processor.saveJob(job);
+        await processor.run(branch, job);
+        return null;
+      }
+    }
+    job.set({
+      status: branchJob.status
+    });
+    return job;
+  }
+  getScope(node, index, processor) {
+    const target = processor.getParsedValue(node.config.target, node.id);
+    const targets = (Array.isArray(target) ? target : [target]).filter((t) => t != null);
+    const length = getTargetLength(target);
+    const item = typeof target === "number" ? index : targets[index];
+    const result = {
+      item,
+      index,
+      length
+    };
+    this.workflow.noticeManager.notify("workflow:regular", {
+      msg: "progress",
+      current: index,
+      total: length
+    });
+    return result;
+  }
+}

package/dist/server/features/loop/Plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginLoop extends Plugin {
+    load(): Promise<void>;
+}

package/dist/server/features/loop/Plugin.js

@@ -0,0 +1,45 @@
+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 __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 Plugin_exports = {};
+__export(Plugin_exports, {
+  PluginLoop: () => PluginLoop
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_LoopInstruction = __toESM(require("./LoopInstruction"));
+class PluginLoop extends import_server.Plugin {
+  async load() {
+    const workflowPlugin = this.app.getPlugin(import__.default);
+    workflowPlugin.registerInstruction("loop", import_LoopInstruction.default);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginLoop
+});

package/dist/server/features/manual/ManualInstruction.d.ts

@@ -0,0 +1,28 @@
+import { Registry } from '@tachybase/utils';
+import WorkflowPlugin, { Instruction, Processor } from '../..';
+import { FormHandler } from './forms';
+type FormType = {
+    type: 'custom' | 'create' | 'update';
+    actions: number[];
+    options: {
+        [key: string]: any;
+    };
+};
+export interface ManualConfig {
+    schema: {
+        [key: string]: any;
+    };
+    forms: {
+        [key: string]: FormType;
+    };
+    assignees?: (number | string)[];
+    mode?: number;
+}
+export default class extends Instruction {
+    workflow: WorkflowPlugin;
+    formTypes: Registry<FormHandler>;
+    constructor(workflow: WorkflowPlugin);
+    run(node: any, prevJob: any, processor: Processor): Promise<any>;
+    resume(node: any, job: any, processor: Processor): Promise<any>;
+}
+export {};