@nocobase/plugin-workflow-dynamic-calculation 0.17.0-alpha.4

package/client.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/client';
+export { default } from './dist/client';

package/client.js

@@ -0,0 +1 @@
+module.exports = require('./dist/client/index.js');

package/dist/client/DynamicCalculation.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+import { SchemaInitializerItemType } from '@nocobase/client';
+import { Instruction, WorkflowVariableInput } from '@nocobase/plugin-workflow/client';
+declare function DynamicExpression({ value, onChange }: {
+    value: any;
+    onChange: any;
+}): React.JSX.Element;
+export default class extends Instruction {
+    title: string;
+    type: string;
+    group: string;
+    description: string;
+    fieldset: {
+        expression: {
+            type: string;
+            title: string;
+            'x-decorator': string;
+            'x-component': string;
+            required: boolean;
+        };
+        scope: {
+            type: string;
+            title: string;
+            'x-decorator': string;
+            'x-component': string;
+            'x-component-props': {
+                changeOnSelect: boolean;
+                variableOptions: {
+                    types: {
+                        type: string;
+                        options: {
+                            collection: string;
+                            entity: boolean;
+                        };
+                    }[];
+                };
+            };
+            'x-reactions': {
+                dependencies: string[];
+                fulfill: {
+                    state: {
+                        visible: string;
+                    };
+                };
+            };
+        };
+    };
+    components: {
+        DynamicExpression: typeof DynamicExpression;
+        WorkflowVariableInput: typeof WorkflowVariableInput;
+        ValueBlock: (() => JSX.Element) & {
+            Initializer: () => JSX.Element;
+            Result: (props: any) => JSX.Element;
+        };
+    };
+    useVariables({ key, title }: {
+        key: any;
+        title: any;
+    }, { types, fieldNames }: {
+        types: any;
+        fieldNames?: {
+            readonly label: "label";
+            readonly value: "value";
+            readonly children: "children";
+        };
+    }): {
+        value: any;
+        label: any;
+    };
+    useInitializers(node: any): SchemaInitializerItemType;
+}
+export {};

package/dist/client/DynamicExpression.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const DynamicExpression: React.ForwardRefExoticComponent<Omit<Partial<Omit<{
+    children?: React.ReactNode;
+}, string | number | symbol> & Omit<any, "ref"> & {
+    children?: React.ReactNode;
+}>, "ref"> & React.RefAttributes<unknown>>;

package/dist/client/Provider.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function Provider(props: any): React.JSX.Element;

package/dist/client/expression.d.ts

@@ -0,0 +1,3 @@
+import { IField } from '@nocobase/client';
+declare const _default: IField;
+export default _default;

package/dist/client/index.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from '@nocobase/client';
+export default class extends Plugin {
+    afterAdd(): Promise<void>;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+    addComponents(): void;
+}

package/dist/client/index.js

@@ -0,0 +1 @@
+(function(n,e){typeof exports=="object"&&typeof module!="undefined"?e(exports,require("@nocobase/client"),require("react/jsx-runtime"),require("react-i18next"),require("@nocobase/plugin-workflow/client"),require("@formily/core"),require("@formily/react"),require("antd"),require("react")):typeof define=="function"&&define.amd?define(["exports","@nocobase/client","react/jsx-runtime","react-i18next","@nocobase/plugin-workflow/client","@formily/core","@formily/react","antd","react"],e):(n=typeof globalThis!="undefined"?globalThis:n||self,e(n["@nocobase/plugin-workflow-dynamic-calculation"]={},n["@nocobase/client"],n.jsxRuntime,n["react-i18next"],n["@nocobase/plugin-workflow"],n["@formily/core"],n["@formily/react"],n.antd,n.react))})(this,function(n,e,o,C,r,g,u,x,c){"use strict";var z=Object.defineProperty,L=Object.defineProperties;var _=Object.getOwnPropertyDescriptors;var F=Object.getOwnPropertySymbols;var U=Object.prototype.hasOwnProperty,G=Object.prototype.propertyIsEnumerable;var v=(n,e,o)=>e in n?z(n,e,{enumerable:!0,configurable:!0,writable:!0,value:o}):n[e]=o,m=(n,e)=>{for(var o in e||(e={}))U.call(e,o)&&v(n,o,e[o]);if(F)for(var o of F(e))G.call(e,o)&&v(n,o,e[o]);return n},y=(n,e)=>L(n,_(e));var f=(n,e,o)=>(v(n,typeof e!="symbol"?e+"":e,o),o);var w=(n,e,o)=>new Promise((C,r)=>{var g=c=>{try{x(o.next(c))}catch(a){r(a)}},u=c=>{try{x(o.throw(c))}catch(a){r(a)}},x=c=>c.done?C(c.value):Promise.resolve(c.value).then(g,u);x((o=o.apply(n,e)).next())});const a="workflow-dynamic-calculation";function k(s,i={}){const{t}=I(i);return t(s)}function I(s){return C.useTranslation(a,s)}const{defaultProps:T}=e.interfacesProperties,P={name:"expression",type:"string",group:"advanced",order:1,title:`{{t("Expression", { ns: "${a}" })}}`,description:`{{t("An expression for calculation in each rows", { ns: "${a}" })}}`,sortable:!0,default:{type:"text",uiSchema:{"x-component":"DynamicExpression"}},properties:m({},T)};function E(s){const i=e.useCollectionManager();return o.jsx(e.CollectionManagerContext.Provider,{value:y(m({},i),{interfaces:y(m({},i.interfaces),{expression:P})}),children:s.children})}function M(s){var t;return["belongsTo","hasOne"].includes(s.type)?((t=this.getCollection(s.collectionName))==null?void 0:t.template)==="expression"?!0:this.getCollectionFields(s.target).some(l=>l.interface==="expression"):!1}function q({value:s,onChange:i}){const{getCollectionFields:t,getCollection:l}=e.useCollectionManager(),d=r.useWorkflowVariableOptions({types:[M.bind({getCollectionFields:t,getCollection:l})]});return o.jsx(e.Variable.Input,{value:s,onChange:i,scope:d})}class j extends r.Instruction{constructor(){super(...arguments);f(this,"title",`{{t("Dynamic Calculation", { ns: "${a}" })}}`);f(this,"type","dynamic-calculation");f(this,"group","control");f(this,"description",`{{t("Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.", { ns: "${a}" })}}`);f(this,"fieldset",{expression:{type:"string",title:`{{t("Calculation expression", { ns: "${a}" })}}`,"x-decorator":"FormItem","x-component":"DynamicExpression",required:!0},scope:{type:"string",title:`{{t("Variable datasource", { ns: "${a}" })}}`,"x-decorator":"FormItem","x-component":"WorkflowVariableInput","x-component-props":{changeOnSelect:!0,variableOptions:{types:[{type:"reference",options:{collection:"*",entity:!0}}]}},"x-reactions":{dependencies:["expression"],fulfill:{state:{visible:"{{$deps[0]}}"}}}}});f(this,"components",{DynamicExpression:q,WorkflowVariableInput:r.WorkflowVariableInput,ValueBlock:r.ValueBlock})}useVariables({key:t,title:l},{types:d,fieldNames:p=r.defaultFieldNames}){return d&&!d.some(h=>h in r.BaseTypeSets||Object.values(r.BaseTypeSets).some(b=>b.has(h)))?null:{[p.value]:t,[p.label]:l}}useInitializers(t){var l;return{name:`#${t.id}`,type:"item",title:(l=t.title)!=null?l:`#${t.id}`,Component:r.ValueBlock.Initializer,node:t,resultTitle:k("Calculation result")}}}const D=u.observer(s=>{const{onChange:i}=s,t=u.useField(),l=u.useForm(),p=[...t.path.segments.slice(0,-1),"sourceCollection"].join("."),[h,b]=c.useState(l.getValuesIn(p)),B=e.useCompile(),{getCollectionFields:W}=e.useCollectionManager();u.useFormEffects(()=>{g.onFormInitialValuesChange(V=>{b(V.getValuesIn(p))}),g.onFieldInputValueChange(p,V=>{b(V.value),i(null)})});const N=r.getCollectionFieldOptions({collection:h,compile:B,getCollectionFields:W});return o.jsx(e.Variable.TextArea,y(m({},s),{scope:N}))},{displayName:"InternalExpression"});function O(s){const{t:i}=C.useTranslation(),t=e.useRecord(),l=e.useCompile(),{getCollectionFields:d}=e.useCollectionManager(),p=c.useMemo(()=>r.getCollectionFieldOptions({collection:t.sourceCollection,compile:l,getCollectionFields:d}),[t.sourceCollection,t.sourceCollection]);return s.value?o.jsx(e.Variable.TextArea,y(m({},s),{scope:p})):o.jsx(x.Tag,{children:i("Unconfigured",{ns:a})})}const S=u.connect(D,u.mapReadPretty(O));class A extends e.Plugin{afterAdd(){return w(this,null,function*(){})}beforeLoad(){return w(this,null,function*(){})}load(){return w(this,null,function*(){this.app.addProvider(E);const i=this.app.pm.get("workflow"),t=new j;i.instructions.register(t.type,t)})}addComponents(){this.app.addComponents({DynamicExpression:S})}}n.default=A,Object.defineProperties(n,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/dist/externalVersion.js

@@ -0,0 +1,13 @@
+module.exports = {
+  "react": "18.2.0",
+  "@nocobase/client": "0.17.0-alpha.4",
+  "@nocobase/plugin-workflow": "0.17.0-alpha.4",
+  "@formily/core": "2.2.27",
+  "@formily/react": "2.2.27",
+  "antd": "5.8.6",
+  "react-i18next": "11.18.6",
+  "@nocobase/utils": "0.17.0-alpha.4",
+  "@nocobase/evaluators": "0.17.0-alpha.4",
+  "@nocobase/server": "0.17.0-alpha.4",
+  "@nocobase/database": "0.17.0-alpha.4"
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './server';
+export { default } from './server';

package/dist/index.js

@@ -0,0 +1,39 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  default: () => import_server.default
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./server"), module.exports);
+var import_server = __toESM(require("./server"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./server")
+});

package/dist/locale/en-US.json

@@ -0,0 +1,11 @@
+{
+  "Dynamic Calculation": "Dynamic Calculation",
+  "Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.": "Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.",
+  "Select dynamic expression": "Select dynamic expression",
+  "Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.": "Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.",
+  "Variable datasource": "Variable datasource",
+  "Dynamic expression": "Dynamic expression",
+  "An expression for calculation in each rows": "An expression for calculation in each rows",
+  "Unconfigured": "Unconfigured",
+  "Calculation result": "Calculation result"
+}

package/dist/locale/index.d.ts

@@ -0,0 +1,3 @@
+export declare const NAMESPACE = "workflow-dynamic-calculation";
+export declare function useLang(key: string, options?: {}): string;
+export declare function usePluginTranslation(options: any): import("react-i18next").UseTranslationResponse<"workflow-dynamic-calculation", undefined>;

package/dist/locale/index.js

@@ -0,0 +1,39 @@
+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 locale_exports = {};
+__export(locale_exports, {
+  NAMESPACE: () => NAMESPACE,
+  useLang: () => useLang,
+  usePluginTranslation: () => usePluginTranslation
+});
+module.exports = __toCommonJS(locale_exports);
+var import_react_i18next = require("react-i18next");
+const NAMESPACE = "workflow-dynamic-calculation";
+function useLang(key, options = {}) {
+  const { t } = usePluginTranslation(options);
+  return t(key);
+}
+function usePluginTranslation(options) {
+  return (0, import_react_i18next.useTranslation)(NAMESPACE, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NAMESPACE,
+  useLang,
+  usePluginTranslation
+});

package/dist/locale/zh-CN.json

@@ -0,0 +1,11 @@
+{
+  "Dynamic Calculation": "动态表达式计算",
+  "Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.": "基于计算引擎计算表达式并获取值作为结果。可以在表达式中使用上游节点的变量。表达式是从表达式表中动态获取的。",
+  "Select dynamic expression": "选择动态表达式",
+  "Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.": "从上游节点中选择查询出来的动态表达式。你需要从动态表达式类型的数据表中查询。",
+  "Variable datasource": "变量数据源",
+  "Dynamic expression": "动态表达式",
+  "An expression for calculation in each rows": "每行数据计算规则不同时使用",
+  "Unconfigured": "未配置",
+  "Calculation result": "运算结果"
+}

package/dist/server/DynamicCalculation.d.ts

@@ -0,0 +1,7 @@
+import { FlowNodeModel, Instruction, Processor } from '@nocobase/plugin-workflow';
+export declare class DynamicCalculation extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<{
+        result: any;
+        status: number;
+    }>;
+}

package/dist/server/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_utils = require("@nocobase/utils");
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+var import_evaluators = __toESM(require("@nocobase/evaluators"));
+class DynamicCalculation extends import_plugin_workflow.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_plugin_workflow.JOB_STATUS.RESOLVED
+      };
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: import_plugin_workflow.JOB_STATUS.ERROR
+      };
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamicCalculation
+});

package/dist/server/Plugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from '@nocobase/server';
+import WorkflowPlugin from '@nocobase/plugin-workflow';
+export default class extends Plugin {
+    workflow: WorkflowPlugin;
+    load(): Promise<void>;
+}

package/dist/server/Plugin.js

@@ -0,0 +1,36 @@
+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 Plugin_exports = {};
+__export(Plugin_exports, {
+  default: () => Plugin_default
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@nocobase/server");
+var import_expression_field = require("./expression-field");
+var import_DynamicCalculation = require("./DynamicCalculation");
+class Plugin_default extends import_server.Plugin {
+  workflow;
+  async load() {
+    this.db.registerFieldTypes({
+      expression: import_expression_field.ExpressionField
+    });
+    const workflowPlugin = this.app.getPlugin("workflow");
+    this.workflow = workflowPlugin;
+    workflowPlugin.instructions.register("dynamic-calculation", new import_DynamicCalculation.DynamicCalculation(workflowPlugin));
+  }
+}

package/dist/server/expression-field.d.ts

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

package/dist/server/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("@nocobase/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/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Plugin';

package/dist/server/index.js

@@ -0,0 +1,33 @@
+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 server_exports = {};
+__export(server_exports, {
+  default: () => import_Plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_Plugin = __toESM(require("./Plugin"));

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@nocobase/plugin-workflow-dynamic-calculation",
+  "displayName": "Workflow: Dynamic calculation node",
+  "displayName.zh-CN": "工作流：动态表达式计算节点",
+  "description": "Useful plugin for doing dynamic calculation based on expression collection records in workflow.",
+  "description.zh-CN": "用于在工作流中进行基于数据行的动态表达式计算。",
+  "version": "0.17.0-alpha.4",
+  "license": "AGPL-3.0",
+  "main": "./dist/server/index.js",
+  "devDependencies": {
+    "@ant-design/icons": "5.x",
+    "@formily/antd-v5": "1.x",
+    "@formily/core": "2.x",
+    "@formily/react": "2.x",
+    "antd": "5.x",
+    "lodash": "4.17.21",
+    "react": "18.x",
+    "react-i18next": "^11.15.1",
+    "react-router-dom": "^6.11.2"
+  },
+  "peerDependencies": {
+    "@nocobase/client": "0.x",
+    "@nocobase/database": "0.x",
+    "@nocobase/evaluators": "0.x",
+    "@nocobase/plugin-collection-manager": "0.x",
+    "@nocobase/plugin-workflow": ">=0.17.0-alpha.3",
+    "@nocobase/plugin-workflow-test": ">=0.17.0-alpha.3",
+    "@nocobase/server": "0.x",
+    "@nocobase/test": "0.x",
+    "@nocobase/utils": "0.x"
+  },
+  "gitHead": "663b03a3799a70ba1a2bc6a0d686e679331a50ad"
+}

package/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');

package/src/client/DynamicCalculation.tsx

@@ -0,0 +1,98 @@
+import React from 'react';
+
+import { SchemaInitializerItemType, Variable, useCollectionManager } from '@nocobase/client';
+import {
+  BaseTypeSets,
+  Instruction,
+  ValueBlock,
+  WorkflowVariableInput,
+  defaultFieldNames,
+  useWorkflowVariableOptions,
+} from '@nocobase/plugin-workflow/client';
+import { NAMESPACE, useLang } from '../locale';
+
+function useDynamicExpressionCollectionFieldMatcher(field): boolean {
+  if (!['belongsTo', 'hasOne'].includes(field.type)) {
+    return false;
+  }
+
+  if (this.getCollection(field.collectionName)?.template === 'expression') {
+    return true;
+  }
+
+  const fields = this.getCollectionFields(field.target);
+  return fields.some((f) => f.interface === 'expression');
+}
+
+function DynamicExpression({ value, onChange }) {
+  const { getCollectionFields, getCollection } = useCollectionManager();
+  const scope = useWorkflowVariableOptions({
+    types: [useDynamicExpressionCollectionFieldMatcher.bind({ getCollectionFields, getCollection })],
+  });
+
+  return <Variable.Input value={value} onChange={onChange} scope={scope} />;
+}
+
+export default class extends Instruction {
+  title = `{{t("Dynamic Calculation", { ns: "${NAMESPACE}" })}}`;
+  type = 'dynamic-calculation';
+  group = 'control';
+  description = `{{t("Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.", { ns: "${NAMESPACE}" })}}`;
+  fieldset = {
+    expression: {
+      type: 'string',
+      title: `{{t("Calculation expression", { ns: "${NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'DynamicExpression',
+      required: true,
+    },
+    scope: {
+      type: 'string',
+      title: `{{t("Variable datasource", { ns: "${NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'WorkflowVariableInput',
+      'x-component-props': {
+        changeOnSelect: true,
+        variableOptions: {
+          types: [{ type: 'reference', options: { collection: '*', entity: true } }],
+        },
+      },
+      'x-reactions': {
+        dependencies: ['expression'],
+        fulfill: {
+          state: {
+            visible: '{{$deps[0]}}',
+          },
+        },
+      },
+    },
+  };
+  components = {
+    DynamicExpression,
+    WorkflowVariableInput,
+    ValueBlock,
+  };
+  useVariables({ key, title }, { types, fieldNames = defaultFieldNames }) {
+    if (
+      types &&
+      !types.some((type) => type in BaseTypeSets || Object.values(BaseTypeSets).some((set) => set.has(type)))
+    ) {
+      return null;
+    }
+    return {
+      [fieldNames.value]: key,
+      [fieldNames.label]: title,
+    };
+  }
+  useInitializers(node): SchemaInitializerItemType {
+    return {
+      name: `#${node.id}`,
+      type: 'item',
+      title: node.title ?? `#${node.id}`,
+      Component: ValueBlock.Initializer,
+      node,
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      resultTitle: useLang('Calculation result'),
+    };
+  }
+}

package/src/client/DynamicExpression.tsx

@@ -0,0 +1,57 @@
+import { onFieldInputValueChange, onFormInitialValuesChange } from '@formily/core';
+import { connect, mapReadPretty, observer, useField, useForm, useFormEffects } from '@formily/react';
+import { Tag } from 'antd';
+import React, { useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useCollectionManager, useCompile, useRecord, Variable } from '@nocobase/client';
+import { getCollectionFieldOptions } from '@nocobase/plugin-workflow/client';
+
+import { NAMESPACE } from '../locale';
+
+const InternalExpression = observer(
+  (props: any) => {
+    const { onChange } = props;
+    const field = useField<any>();
+    // TODO(refactor): better to provide another context like useFieldset()
+    const form = useForm();
+    const basePath = field.path.segments.slice(0, -1);
+    const collectionPath = [...basePath, 'sourceCollection'].join('.');
+    const [collection, setCollection] = useState(form.getValuesIn(collectionPath));
+    const compile = useCompile();
+    const { getCollectionFields } = useCollectionManager();
+
+    useFormEffects(() => {
+      onFormInitialValuesChange((form) => {
+        setCollection(form.getValuesIn(collectionPath));
+      });
+      onFieldInputValueChange(collectionPath, (f) => {
+        setCollection(f.value);
+        onChange(null);
+      });
+    });
+
+    const options = getCollectionFieldOptions({ collection, compile, getCollectionFields });
+
+    return <Variable.TextArea {...props} scope={options} />;
+  },
+  { displayName: 'InternalExpression' },
+);
+
+function Result(props) {
+  const { t } = useTranslation();
+  const values = useRecord();
+  const compile = useCompile();
+  const { getCollectionFields } = useCollectionManager();
+  const options = useMemo(
+    () => getCollectionFieldOptions({ collection: values.sourceCollection, compile, getCollectionFields }),
+    [values.sourceCollection, values.sourceCollection],
+  );
+  return props.value ? (
+    <Variable.TextArea {...props} scope={options} />
+  ) : (
+    <Tag>{t('Unconfigured', { ns: NAMESPACE })}</Tag>
+  );
+}
+
+export const DynamicExpression = connect(InternalExpression, mapReadPretty(Result));