@nocobase/plugin-workflow 0.9.0-alpha.2 → 0.9.1-alpha.1

package/lib/client/nodes/calculation.js

@@ -25,12 +25,56 @@ function _css() {
   return data;
 }
 
-var _calculators = require("../calculators");
+function _jsonTemplates() {
+  const data = _interopRequireDefault(require("json-templates"));
+
+  _jsonTemplates = function _jsonTemplates() {
+    return data;
+  };
+
+  return data;
+}
+
+function _client() {
+  const data = require("@nocobase/client");
+
+  _client = function _client() {
+    return data;
+  };
+
+  return data;
+}
+
+function _client2() {
+  const data = _interopRequireWildcard(require("@nocobase/evaluators/client"));
+
+  _client2 = function _client2() {
+    return data;
+  };
+
+  return data;
+}
+
+var _FlowContext = require("../FlowContext");
 
 var _locale = require("../locale");
 
+var _variable = require("../variable");
+
+var _RadioWithTooltip = require("../components/RadioWithTooltip");
+
+const _excluded = ["node", "insert"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
@@ -42,36 +86,144 @@ var _default = {
   type: 'calculation',
   group: 'control',
   fieldset: {
-    'config.calculation': {
-      type: 'object',
-      title: `{{t("Configure calculation", { ns: "${_locale.NAMESPACE}" })}}`,
-      name: 'config.calculation',
+    'config.engine': {
+      type: 'string',
+      title: `{{t("Calculation engine", { ns: "${_locale.NAMESPACE}" })}}`,
+      name: 'config.engine',
+      'x-decorator': 'FormItem',
+      'x-component': 'RadioWithTooltip',
+      'x-component-props': {
+        options: Array.from(_client2().default.getEntities()).reduce((result, [value, options]) => result.concat(_objectSpread({
+          value
+        }, options)), [])
+      },
       required: true,
+      default: 'math.js'
+    },
+    'config.expression': {
+      type: 'string',
+      title: `{{t("Calculation expression", { ns: "${_locale.NAMESPACE}" })}}`,
+      name: 'config.expression',
       'x-decorator': 'FormItem',
-      'x-component': 'CalculationConfig'
+      'x-component': 'Variable.TextArea',
+      'x-component-props': {
+        scope: '{{useWorkflowVariableOptions}}'
+      },
+
+      ['x-validator'](value, rules, {
+        form
+      }) {
+        const values = form.values;
+
+        const _evaluators$get = _client2().default.get(values.config.engine),
+              evaluate = _evaluators$get.evaluate;
+
+        const exp = value.trim().replace(/{{([^{}]+)}}/g, '1');
+
+        try {
+          evaluate(exp);
+          return '';
+        } catch (e) {
+          return (0, _locale.lang)('Expression syntax error');
+        }
+      },
+
+      'x-reactions': {
+        dependencies: ['config.engine'],
+        fulfill: {
+          schema: {
+            description: '{{renderReference($deps[0])}}'
+          }
+        }
+      },
+      required: true
     }
   },
   view: {},
+  scope: {
+    useWorkflowVariableOptions: _variable.useWorkflowVariableOptions,
+    renderReference: _client2().renderReference
+  },
   components: {
-    CalculationConfig({
-      value,
-      onChange
+    CalculationResult({
+      dataSource
     }) {
-      return _react().default.createElement(_calculators.Calculation, _objectSpread(_objectSpread({}, value), {}, {
-        onChange: onChange
-      }));
+      var _execution$jobs;
+
+      const _useFlowContext = (0, _FlowContext.useFlowContext)(),
+            execution = _useFlowContext.execution;
+
+      if (!execution) {
+        return (0, _locale.lang)('Calculation result');
+      }
+
+      const result = (0, _jsonTemplates().default)(dataSource)({
+        $jobsMapByNodeId: ((_execution$jobs = execution.jobs) !== null && _execution$jobs !== void 0 ? _execution$jobs : []).reduce((map, job) => Object.assign(map, {
+          [job.nodeId]: job.result
+        }), {})
+      });
+      return _react().default.createElement("pre", {
+        className: (0, _css().css)`
+          margin: 0;
+        `
+      }, JSON.stringify(result, null, 2));
+    },
+
+    RadioWithTooltip: _RadioWithTooltip.RadioWithTooltip
+  },
+
+  getOptions(config, types) {
+    if (types && !types.some(type => type in _variable.TypeSets || Object.values(_variable.TypeSets).some(set => set.has(type)))) {
+      return null;
     }
 
+    return [// { key: '', value: '', label: lang('Calculation result') }
+    ];
   },
 
-  getter() {
-    const _useWorkflowTranslati = (0, _locale.useWorkflowTranslation)(),
-          t = _useWorkflowTranslati.t;
+  useInitializers(node) {
+    var _node$title;
 
-    return _react().default.createElement("div", {
-      className: (0, _css().css)`flex-shrink: 0`
-    }, t('Calculation result'));
+    return {
+      type: 'item',
+      title: (_node$title = node.title) !== null && _node$title !== void 0 ? _node$title : `#${node.id}`,
+      component: CalculationInitializer,
+      node
+    };
   }
 
 };
-exports.default = _default;
+exports.default = _default;
+
+function CalculationInitializer(_ref) {
+  let node = _ref.node,
+      insert = _ref.insert,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  return _react().default.createElement(_client().SchemaInitializer.Item, _objectSpread(_objectSpread({}, props), {}, {
+    onClick: () => {
+      var _node$title2;
+
+      insert({
+        type: 'void',
+        name: node.id,
+        title: node.title,
+        'x-component': 'CardItem',
+        'x-component-props': {
+          title: (_node$title2 = node.title) !== null && _node$title2 !== void 0 ? _node$title2 : `#${node.id}`
+        },
+        'x-designer': 'SimpleDesigner',
+        properties: {
+          result: {
+            type: 'void',
+            'x-component': 'CalculationResult',
+            'x-component-props': {
+              // NOTE: as same format as other reference for migration of revision
+              dataSource: `{{$jobsMapByNodeId.${node.id}}}`
+            }
+          }
+        }
+      });
+    }
+  }));
+}

package/lib/client/nodes/condition.d.ts

@@ -1,4 +1,18 @@
 /// <reference types="react" />
+import { Registry } from "@nocobase/utils/client";
+import { useWorkflowVariableOptions } from "../variable";
+import { RadioWithTooltip } from "../components/RadioWithTooltip";
+interface Calculator {
+    name: string;
+    type: 'boolean' | 'number' | 'string' | 'date' | 'unknown' | 'null' | 'array';
+    group: string;
+}
+export declare const calculators: Registry<Calculator>;
+export declare function Calculation({ calculator, operands, onChange }: {
+    calculator: any;
+    operands?: any[];
+    onChange: any;
+}): JSX.Element;
 declare function CalculationConfig({ value, onChange }: {
     value: any;
     onChange: any;
@@ -22,12 +36,60 @@ declare const _default: {
                 label: string;
             }[];
         };
+        'config.engine': {
+            type: string;
+            title: string;
+            name: string;
+            'x-decorator': string;
+            'x-component': string;
+            'x-component-props': {
+                options: [string, import("@nocobase/evaluators/client").Evaluator] | (string | {
+                    label: string;
+                })[];
+            };
+            required: boolean;
+            default: string;
+        };
         'config.calculation': {
             type: string;
             name: string;
             title: string;
             'x-decorator': string;
             'x-component': string;
+            'x-reactions': {
+                dependencies: string[];
+                fulfill: {
+                    state: {
+                        visible: string;
+                    };
+                };
+            };
+            required: boolean;
+        };
+        'config.expression': {
+            type: string;
+            title: string;
+            name: string;
+            'x-decorator': string;
+            'x-component': string;
+            'x-component-props': {
+                scope: string;
+            };
+            "x-validator"(value: any, rules: any, { form }: {
+                form: any;
+            }): string;
+            'x-reactions': {
+                dependencies: string[];
+                fulfill: {
+                    state: {
+                        visible: string;
+                    };
+                    schema: {
+                        description: string;
+                    };
+                };
+            };
+            required: boolean;
         };
     };
     view: {};
@@ -39,8 +101,13 @@ declare const _default: {
         };
     }[];
     render(data: any): JSX.Element;
+    scope: {
+        renderReference: (key: string) => JSX.Element;
+        useWorkflowVariableOptions: typeof useWorkflowVariableOptions;
+    };
     components: {
         CalculationConfig: typeof CalculationConfig;
+        RadioWithTooltip: typeof RadioWithTooltip;
     };
 };
 export default _default;