@nocobase/plugin-workflow 0.7.1-alpha.5 → 0.7.2-alpha.1

package/lib/client/calculators.js

@@ -0,0 +1,739 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseTypeSet = void 0;
+exports.Calculation = Calculation;
+exports.CollectionFieldset = void 0;
+exports.Operand = Operand;
+exports.VariableComponent = VariableComponent;
+exports.calculators = exports.VariableTypesContext = exports.VariableTypes = void 0;
+exports.parseStringValue = parseStringValue;
+exports.useVariableTypes = useVariableTypes;
+
+function _react() {
+  const data = _interopRequireDefault(require("react"));
+
+  _react = function _react() {
+    return data;
+  };
+
+  return data;
+}
+
+function _react2() {
+  const data = require("@formily/react");
+
+  _react2 = function _react2() {
+    return data;
+  };
+
+  return data;
+}
+
+function _antd() {
+  const data = require("antd");
+
+  _antd = function _antd() {
+    return data;
+  };
+
+  return data;
+}
+
+function _css() {
+  const data = require("@emotion/css");
+
+  _css = function _css() {
+    return data;
+  };
+
+  return data;
+}
+
+function _icons() {
+  const data = require("@ant-design/icons");
+
+  _icons = function _icons() {
+    return data;
+  };
+
+  return data;
+}
+
+function _client() {
+  const data = require("@nocobase/client");
+
+  _client = function _client() {
+    return data;
+  };
+
+  return data;
+}
+
+var _nodes = require("./nodes");
+
+var _WorkflowCanvas = require("./WorkflowCanvas");
+
+var _triggers = require("./triggers");
+
+function _reactI18next() {
+  const data = require("react-i18next");
+
+  _reactI18next = function _reactI18next() {
+    return data;
+  };
+
+  return data;
+}
+
+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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+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; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function NullRender() {
+  return null;
+}
+
+const calculators = [{
+  value: 'boolean',
+  title: '{{t("Comparison")}}',
+  children: [{
+    value: 'equal',
+    name: '='
+  }, {
+    value: 'notEqual',
+    name: '≠'
+  }, {
+    value: 'gt',
+    name: '>'
+  }, {
+    value: 'gte',
+    name: '≥'
+  }, {
+    value: 'lt',
+    name: '<'
+  }, {
+    value: 'lte',
+    name: '≤'
+  }]
+}, {
+  value: 'number',
+  title: '{{t("Arithmetic calculation")}}',
+  children: [{
+    value: 'add',
+    name: '+'
+  }, {
+    value: 'minus',
+    name: '-'
+  }, {
+    value: 'multiple',
+    name: '*'
+  }, {
+    value: 'divide',
+    name: '/'
+  }, {
+    value: 'mod',
+    name: '%'
+  }]
+}, {
+  value: 'string',
+  title: '{{t("String operation")}}',
+  children: [{
+    value: 'includes',
+    name: '{{t("contains")}}'
+  }, {
+    value: 'notIncludes',
+    name: '{{t("does not contain")}}'
+  }, {
+    value: 'startsWith',
+    name: '{{t("starts with")}}'
+  }, {
+    value: 'notStartsWith',
+    name: '{{t("not starts with")}}'
+  }, {
+    value: 'endsWith',
+    name: '{{t("ends with")}}'
+  }, {
+    value: 'notEndsWith',
+    name: '{{t("not ends with")}}'
+  }]
+}, {
+  value: 'date',
+  title: '{{t("Date")}}',
+  children: []
+}];
+exports.calculators = calculators;
+const JT_VALUE_RE = /^\s*\{\{([\s\S]*)\}\}\s*$/;
+
+function parseStringValue(value, Types) {
+  var _type;
+
+  const matcher = value.match(JT_VALUE_RE);
+
+  if (!matcher) {
+    return {
+      type: 'constant',
+      value,
+      options: {
+        type: 'string'
+      }
+    };
+  }
+
+  const _matcher$1$split = matcher[1].split('.'),
+        _matcher$1$split2 = _toArray(_matcher$1$split),
+        type = _matcher$1$split2[0],
+        paths = _matcher$1$split2.slice(1);
+
+  return {
+    type,
+    options: paths.length ? (_type = (Types || VariableTypes)[type]) === null || _type === void 0 ? void 0 : _type.parse(paths) : {}
+  };
+}
+
+const BaseTypeSet = new Set(['boolean', 'number', 'string', 'date']);
+exports.BaseTypeSet = BaseTypeSet;
+const ConstantTypes = {
+  string: {
+    title: '{{t("String")}}',
+    value: 'string',
+
+    component({
+      onChange: _onChange,
+      type,
+      options,
+      value
+    }) {
+      return _react().default.createElement(_antd().Input, {
+        value: value,
+        onChange: ev => _onChange({
+          value: ev.target.value,
+          type,
+          options
+        })
+      });
+    },
+
+    default: ''
+  },
+  number: {
+    title: '{{t("Number")}}',
+    value: 'number',
+
+    component({
+      onChange: _onChange2,
+      type,
+      options,
+      value
+    }) {
+      return _react().default.createElement(_antd().InputNumber, {
+        value: value,
+        onChange: v => _onChange2({
+          value: v,
+          type,
+          options
+        })
+      });
+    },
+
+    default: 0
+  },
+  boolean: {
+    title: '{{t("Boolean")}}',
+    value: 'boolean',
+
+    component({
+      onChange: _onChange3,
+      type,
+      options,
+      value
+    }) {
+      const _useTranslation = (0, _reactI18next().useTranslation)(),
+            t = _useTranslation.t;
+
+      return _react().default.createElement(_antd().Select, {
+        value: value,
+        onChange: v => _onChange3({
+          value: v,
+          type,
+          options
+        }),
+        placeholder: t('Select')
+      }, _react().default.createElement(_antd().Select.Option, {
+        value: true
+      }, t('True')), _react().default.createElement(_antd().Select.Option, {
+        value: false
+      }, t('False')));
+    },
+
+    default: false
+  } // date: {
+  //   title: '日期',
+  //   value: 'date',
+  //   component({ onChange, type, options, value }) {
+  //     return <DatePicker value={value} onChange={v => onChange({ value: v, type, options })}/>;
+  //   },
+  //   default: new Date()
+  // }
+
+};
+const VariableTypes = {
+  constant: {
+    title: '{{t("Constant")}}',
+    value: 'constant',
+    options: Object.values(ConstantTypes).map(item => ({
+      value: item.value,
+      label: item.title
+    })),
+
+    component({
+      options = {
+        type: 'string'
+      }
+    }) {
+      var _ConstantTypes$option, _ConstantTypes$option2;
+
+      return (_ConstantTypes$option = (_ConstantTypes$option2 = ConstantTypes[options.type]) === null || _ConstantTypes$option2 === void 0 ? void 0 : _ConstantTypes$option2.component) !== null && _ConstantTypes$option !== void 0 ? _ConstantTypes$option : NullRender;
+    },
+
+    appendTypeValue({
+      options = {
+        type: 'string'
+      }
+    }) {
+      return (options === null || options === void 0 ? void 0 : options.type) ? [options.type] : [];
+    },
+
+    onTypeChange(old, [type, optionsType], onChange) {
+      var _old$options;
+
+      if ((old === null || old === void 0 ? void 0 : (_old$options = old.options) === null || _old$options === void 0 ? void 0 : _old$options.type) === optionsType) {
+        return;
+      }
+
+      const value = ConstantTypes[optionsType].default;
+      onChange({
+        value,
+        type,
+        options: _objectSpread(_objectSpread({}, old.options), {}, {
+          type: optionsType
+        })
+      });
+    },
+
+    parse(path) {
+      return {
+        path
+      };
+    }
+
+  },
+  $jobsMapByNodeId: {
+    title: '{{t("Node result")}}',
+    value: '$jobsMapByNodeId',
+
+    options() {
+      const node = (0, _nodes.useNodeContext)();
+      const stack = [];
+
+      for (let current = node.upstream; current; current = current.upstream) {
+        const _instructions$get = _nodes.instructions.get(current.type),
+              getter = _instructions$get.getter; // Note: consider `getter` as the key of a value available node
+
+
+        if (getter) {
+          var _current$title;
+
+          stack.push({
+            value: current.id,
+            label: (_current$title = current.title) !== null && _current$title !== void 0 ? _current$title : `#${current.id}`
+          });
+        }
+      }
+
+      return stack;
+    },
+
+    component({
+      options
+    }) {
+      var _instruction$getter;
+
+      const _useFlowContext = (0, _WorkflowCanvas.useFlowContext)(),
+            nodes = _useFlowContext.nodes;
+
+      if (!(options === null || options === void 0 ? void 0 : options.nodeId)) {
+        return NullRender;
+      }
+
+      const node = nodes.find(n => n.id == options.nodeId);
+
+      if (!node) {
+        return NullRender;
+      }
+
+      const instruction = _nodes.instructions.get(node.type);
+
+      return (_instruction$getter = instruction === null || instruction === void 0 ? void 0 : instruction.getter) !== null && _instruction$getter !== void 0 ? _instruction$getter : NullRender;
+    },
+
+    appendTypeValue({
+      options = {}
+    }) {
+      return options.nodeId ? [Number.parseInt(options.nodeId, 10)] : [];
+    },
+
+    onTypeChange(old, [type, nodeId], onChange) {
+      onChange({
+        // ...old,
+        type,
+        options: {
+          nodeId
+        }
+      });
+    },
+
+    parse([nodeId, ...path]) {
+      return {
+        nodeId,
+        path: path.join('.')
+      };
+    },
+
+    stringify({
+      options
+    }) {
+      const stack = ['$jobsMapByNodeId'];
+
+      if (options.nodeId) {
+        stack.push(options.nodeId);
+
+        if (options.path) {
+          stack.push(options.path);
+        }
+      }
+
+      return `{{${stack.join('.')}}}`;
+    }
+
+  },
+  $context: {
+    title: '{{t("Trigger context")}}',
+    value: '$context',
+
+    component() {
+      var _trigger$getter;
+
+      const _useFlowContext2 = (0, _WorkflowCanvas.useFlowContext)(),
+            workflow = _useFlowContext2.workflow;
+
+      const trigger = _triggers.triggers.get(workflow.type);
+
+      return (_trigger$getter = trigger === null || trigger === void 0 ? void 0 : trigger.getter) !== null && _trigger$getter !== void 0 ? _trigger$getter : NullRender;
+    },
+
+    parse([prefix, ...path]) {
+      return {
+        path: path.join('.')
+      };
+    },
+
+    stringify({
+      options
+    }) {
+      const stack = ['$context'];
+
+      if (options === null || options === void 0 ? void 0 : options.path) {
+        stack.push(options.path);
+      }
+
+      return `{{${stack.join('.')}}}`;
+    }
+
+  } // calculation: Calculation
+
+};
+exports.VariableTypes = VariableTypes;
+
+const VariableTypesContext = _react().default.createContext(null);
+
+exports.VariableTypesContext = VariableTypesContext;
+
+function useVariableTypes() {
+  return _react().default.useContext(VariableTypesContext);
+}
+
+function Operand({
+  value: operand = {
+    type: 'constant',
+    value: '',
+    options: {
+      type: 'string'
+    }
+  },
+  onChange: _onChange4,
+  children
+}) {
+  const compile = (0, _client().useCompile)();
+  const Types = useVariableTypes();
+  const type = operand.type;
+
+  const _ref = Types[type] || {},
+        component = _ref.component,
+        appendTypeValue = _ref.appendTypeValue;
+
+  const VariableComponent = typeof component === 'function' ? component(operand) : NullRender;
+  return _react().default.createElement("div", {
+    className: (0, _css().css)`
+      display: flex;
+      gap: .5em;
+      align-items: center;
+    `
+  }, _react().default.createElement(_antd().Cascader, {
+    allowClear: false,
+    value: [type, ...(appendTypeValue ? appendTypeValue(operand) : [])],
+    options: Object.values(Types).map(item => {
+      const options = typeof item.options === 'function' ? item.options() : item.options;
+      return {
+        label: compile(item.title),
+        value: item.value,
+        children: compile(options),
+        disabled: options && !options.length,
+        isLeaf: !options
+      };
+    }),
+    onChange: next => {
+      const onTypeChange = Types[next[0]].onTypeChange;
+
+      if (typeof onTypeChange === 'function') {
+        onTypeChange(operand, next, _onChange4);
+      } else {
+        if (next[0] !== type) {
+          _onChange4({
+            type: next[0],
+            value: null
+          });
+        }
+      }
+    }
+  }), children !== null && children !== void 0 ? children : _react().default.createElement(VariableComponent, _objectSpread(_objectSpread({}, operand), {}, {
+    onChange: op => _onChange4(_objectSpread({}, op))
+  })));
+}
+
+function Calculation({
+  calculator,
+  operands = [],
+  onChange: _onChange5
+}) {
+  const _useTranslation2 = (0, _reactI18next().useTranslation)(),
+        t = _useTranslation2.t;
+
+  const compile = (0, _client().useCompile)();
+  return _react().default.createElement(VariableTypesContext.Provider, {
+    value: VariableTypes
+  }, _react().default.createElement("div", {
+    className: (0, _css().css)`
+        display: flex;
+        gap: .5em;
+        align-items: center;
+      `
+  }, _react().default.createElement(Operand, {
+    value: operands[0],
+    onChange: v => _onChange5({
+      calculator,
+      operands: [v, operands[1]]
+    })
+  }), operands[0] ? _react().default.createElement(_react().default.Fragment, null, _react().default.createElement(_antd().Select, {
+    value: calculator,
+    onChange: v => _onChange5({
+      operands,
+      calculator: v
+    }),
+    placeholder: t('Calculator')
+  }, calculators.map(group => _react().default.createElement(_antd().Select.OptGroup, {
+    key: group.value,
+    label: compile(group.title)
+  }, group.children.map(item => _react().default.createElement(_antd().Select.Option, {
+    key: item.value,
+    value: item.value
+  }, compile(item.name)))))), _react().default.createElement(Operand, {
+    value: operands[1],
+    onChange: v => _onChange5({
+      calculator,
+      operands: [operands[0], v]
+    })
+  })) : null));
+}
+
+function VariableComponent({
+  value,
+  onChange: _onChange6,
+  renderSchemaComponent
+}) {
+  const VTypes = _objectSpread(_objectSpread({}, VariableTypes), {}, {
+    constant: {
+      title: '{{t("Constant")}}',
+      value: 'constant',
+      options: undefined
+    }
+  });
+
+  const operand = typeof value === 'string' ? parseStringValue(value, VTypes) : {
+    type: 'constant',
+    value
+  };
+  return _react().default.createElement(VariableTypesContext.Provider, {
+    value: VTypes
+  }, _react().default.createElement(Operand, {
+    value: operand,
+    onChange: next => {
+      if (next.type !== operand.type && next.type === 'constant') {
+        _onChange6(null);
+      } else {
+        const stringify = VTypes[next.type].stringify;
+
+        _onChange6(stringify(next));
+      }
+    }
+  }, operand.type === 'constant' ? renderSchemaComponent() : null));
+} // NOTE: observer for watching useProps
+
+
+const CollectionFieldset = (0, _react2().observer)(({
+  value,
+  onChange: _onChange7
+}) => {
+  var _data$config;
+
+  const _useTranslation3 = (0, _reactI18next().useTranslation)(),
+        t = _useTranslation3.t;
+
+  const compile = (0, _client().useCompile)();
+
+  const _useCollectionManager = (0, _client().useCollectionManager)(),
+        getCollectionFields = _useCollectionManager.getCollectionFields;
+
+  const _useForm = (0, _react2().useForm)(),
+        data = _useForm.values;
+
+  const fields = getCollectionFields(data === null || data === void 0 ? void 0 : (_data$config = data.config) === null || _data$config === void 0 ? void 0 : _data$config.collection).filter(field => !field.hidden && (field.uiSchema ? !field.uiSchema['x-read-pretty'] : false));
+
+  const VTypes = _objectSpread(_objectSpread({}, VariableTypes), {}, {
+    constant: {
+      title: '{{t("Constant")}}',
+      value: 'constant',
+      options: undefined
+    }
+  });
+
+  return _react().default.createElement("fieldset", {
+    className: (0, _css().css)`
+      margin-top: .5em;
+
+      > .ant-formily-item{
+        flex-direction: column;
+
+        > .ant-formily-item-label{
+          line-height: 32px;
+        }
+      }
+    `
+  }, fields.length ? _react().default.createElement(_react().default.Fragment, null, fields.filter(field => field.name in value).map(field => {
+    var _field$uiSchema$title, _field$uiSchema;
+
+    const operand = typeof value[field.name] === 'string' ? parseStringValue(value[field.name], VTypes) : {
+      type: 'constant',
+      value: value[field.name]
+    }; // TODO: try to use <ObjectField> to replace this map
+
+    return _react().default.createElement(_antd().Form.Item, {
+      key: field.name,
+      label: compile((_field$uiSchema$title = (_field$uiSchema = field.uiSchema) === null || _field$uiSchema === void 0 ? void 0 : _field$uiSchema.title) !== null && _field$uiSchema$title !== void 0 ? _field$uiSchema$title : field.name),
+      labelAlign: "left",
+      className: (0, _css().css)`
+                  .ant-form-item-control-input-content{
+                    display: flex;
+                  }
+                `
+    }, _react().default.createElement(VariableTypesContext.Provider, {
+      value: VTypes
+    }, _react().default.createElement(Operand, {
+      value: operand,
+      onChange: next => {
+        if (next.type !== operand.type && next.type === 'constant') {
+          _onChange7(_objectSpread(_objectSpread({}, value), {}, {
+            [field.name]: null
+          }));
+        } else {
+          const stringify = VTypes[next.type].stringify;
+
+          _onChange7(_objectSpread(_objectSpread({}, value), {}, {
+            [field.name]: stringify(next)
+          }));
+        }
+      }
+    }, operand.type === 'constant' ? _react().default.createElement(_client().SchemaComponent, {
+      schema: _objectSpread(_objectSpread({}, field.uiSchema), {}, {
+        name: field.name
+      })
+    }) : null), _react().default.createElement(_antd().Button, {
+      type: "link",
+      icon: _react().default.createElement(_icons().CloseCircleOutlined, null),
+      onClick: () => {
+        const _field$name = field.name,
+              _ = value[_field$name],
+              rest = _objectWithoutProperties(value, [_field$name].map(_toPropertyKey));
+
+        _onChange7(rest);
+      }
+    })));
+  }), Object.keys(value).length < fields.length ? _react().default.createElement(_antd().Dropdown, {
+    overlay: _react().default.createElement(_antd().Menu, {
+      onClick: ({
+        key
+      }) => _onChange7(_objectSpread(_objectSpread({}, value), {}, {
+        [key]: null
+      })),
+      className: (0, _css().css)`
+                    max-height: 300px;
+                    overflow-y: auto;
+                  `
+    }, fields.filter(field => !(field.name in value)).map(field => {
+      var _field$uiSchema$title2, _field$uiSchema2;
+
+      return _react().default.createElement(_antd().Menu.Item, {
+        key: field.name
+      }, compile((_field$uiSchema$title2 = (_field$uiSchema2 = field.uiSchema) === null || _field$uiSchema2 === void 0 ? void 0 : _field$uiSchema2.title) !== null && _field$uiSchema$title2 !== void 0 ? _field$uiSchema$title2 : field.name));
+    }))
+  }, _react().default.createElement(_antd().Button, {
+    icon: _react().default.createElement(_icons().PlusOutlined, null)
+  }, t('Add field'))) : null) : _react().default.createElement("p", null, t('Please select collection first')));
+});
+exports.CollectionFieldset = CollectionFieldset;