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

package/lib/client/nodes/manual/WorkflowTodo.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare function WorkflowTodo(): JSX.Element;
+export declare namespace WorkflowTodo {
+    var Drawer: () => JSX.Element;
+    var Decorator: ({ children }: {
+        children: any;
+    }) => JSX.Element;
+}

package/lib/client/nodes/manual/WorkflowTodo.js

@@ -0,0 +1,691 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkflowTodo = WorkflowTodo;
+
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+
+  _react = function _react() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@formily/core");
+
+  _core = function _core() {
+    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 _jsonTemplates() {
+  const data = _interopRequireDefault(require("json-templates"));
+
+  _jsonTemplates = function _jsonTemplates() {
+    return data;
+  };
+
+  return data;
+}
+
+function _css() {
+  const data = require("@emotion/css");
+
+  _css = function _css() {
+    return data;
+  };
+
+  return data;
+}
+
+function _moment() {
+  const data = _interopRequireDefault(require("moment"));
+
+  _moment = function _moment() {
+    return data;
+  };
+
+  return data;
+}
+
+function _client() {
+  const data = require("@nocobase/client");
+
+  _client = function _client() {
+    return data;
+  };
+
+  return data;
+}
+
+function _client2() {
+  const data = require("@nocobase/utils/client");
+
+  _client2 = function _client2() {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require("../../constants");
+
+var _locale = require("../../locale");
+
+var _FlowContext = require("../../FlowContext");
+
+var _ = require("..");
+
+var _utils = require("../../utils");
+
+const _excluded = ["nodes"],
+      _excluded2 = ["workflow"],
+      _excluded3 = ["collections"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 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 _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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+const nodeCollection = {
+  title: `{{t("Task", { ns: "${_locale.NAMESPACE}" })}}`,
+  name: 'flow_nodes',
+  fields: [{
+    type: 'bigInt',
+    name: 'id',
+    interface: 'm2o',
+    uiSchema: {
+      type: 'number',
+      title: 'ID',
+      'x-component': 'RemoteSelect',
+      'x-component-props': {
+        fieldNames: {
+          label: 'title',
+          value: 'id'
+        },
+        service: {
+          resource: 'flow_nodes',
+          params: {
+            filter: {
+              type: 'manual'
+            }
+          }
+        }
+      }
+    }
+  }, {
+    type: 'string',
+    name: 'title',
+    interface: 'input',
+    uiSchema: {
+      type: 'string',
+      title: '{{t("Title")}}',
+      'x-component': 'Input'
+    }
+  }]
+};
+const workflowCollection = {
+  title: `{{t("Workflow", { ns: "${_locale.NAMESPACE}" })}}`,
+  name: 'workflows',
+  fields: [{
+    type: 'string',
+    name: 'title',
+    interface: 'input',
+    uiSchema: {
+      title: '{{t("Name")}}',
+      type: 'string',
+      'x-component': 'Input',
+      required: true
+    }
+  }]
+};
+const todoCollection = {
+  title: `{{t("Workflow todos", { ns: "${_locale.NAMESPACE}" })}}`,
+  name: 'users_jobs',
+  fields: [{
+    type: 'belongsTo',
+    name: 'user',
+    target: 'users',
+    foreignKey: 'userId',
+    interface: 'm2o',
+    uiSchema: {
+      type: 'number',
+      title: '{{t("User")}}',
+      'x-component': 'RemoteSelect',
+      'x-component-props': {
+        fieldNames: {
+          label: 'nickname',
+          value: 'id'
+        },
+        service: {
+          resource: 'users'
+        }
+      }
+    }
+  }, {
+    type: 'belongsTo',
+    name: 'node',
+    target: 'flow_nodes',
+    foreignKey: 'nodeId',
+    interface: 'm2o',
+    isAssociation: true,
+    uiSchema: {
+      type: 'number',
+      title: `{{t("Task", { ns: "${_locale.NAMESPACE}" })}}`,
+      'x-component': 'RemoteSelect',
+      'x-component-props': {
+        fieldNames: {
+          label: 'title',
+          value: 'id'
+        },
+        service: {
+          resource: 'flow_nodes'
+        }
+      }
+    }
+  }, {
+    type: 'belongsTo',
+    name: 'workflow',
+    target: 'workflows',
+    foreignKey: 'workflowId',
+    interface: 'm2o',
+    uiSchema: {
+      type: 'number',
+      title: `{{t("Workflow", { ns: "${_locale.NAMESPACE}" })}}`,
+      'x-component': 'RemoteSelect',
+      'x-component-props': {
+        fieldNames: {
+          label: 'title',
+          value: 'id'
+        },
+        service: {
+          resource: 'workflows'
+        }
+      }
+    }
+  }, {
+    type: 'integer',
+    name: 'status',
+    interface: 'select',
+    uiSchema: {
+      type: 'number',
+      title: `{{t("Status", { ns: "${_locale.NAMESPACE}" })}}`,
+      'x-component': 'Select',
+      enum: _constants.JobStatusOptions
+    }
+  }, {
+    name: 'createdAt',
+    type: 'date',
+    interface: 'createdAt',
+    uiSchema: {
+      type: 'datetime',
+      title: '{{t("Created at")}}',
+      'x-component': 'DatePicker',
+      'x-component-props': {
+        showTime: true
+      },
+      'x-read-pretty': true
+    }
+  }]
+};
+const NodeColumn = (0, _react2().observer)(() => {
+  var _field$value$title, _field$value, _field$value2;
+
+  const field = (0, _react2().useField)();
+  return (_field$value$title = field === null || field === void 0 ? void 0 : (_field$value = field.value) === null || _field$value === void 0 ? void 0 : _field$value.title) !== null && _field$value$title !== void 0 ? _field$value$title : `#${(_field$value2 = field.value) === null || _field$value2 === void 0 ? void 0 : _field$value2.id}`;
+});
+const WorkflowColumn = (0, _react2().observer)(() => {
+  var _field$value$title2, _field$value3, _field$value4;
+
+  const field = (0, _react2().useField)();
+  return (_field$value$title2 = field === null || field === void 0 ? void 0 : (_field$value3 = field.value) === null || _field$value3 === void 0 ? void 0 : _field$value3.title) !== null && _field$value$title2 !== void 0 ? _field$value$title2 : `#${(_field$value4 = field.value) === null || _field$value4 === void 0 ? void 0 : _field$value4.id}`;
+});
+const UserColumn = (0, _react2().observer)(() => {
+  var _field$value$nickname, _field$value5, _field$value6;
+
+  const field = (0, _react2().useField)();
+  return (_field$value$nickname = field === null || field === void 0 ? void 0 : (_field$value5 = field.value) === null || _field$value5 === void 0 ? void 0 : _field$value5.nickname) !== null && _field$value$nickname !== void 0 ? _field$value$nickname : (_field$value6 = field.value) === null || _field$value6 === void 0 ? void 0 : _field$value6.id;
+});
+
+function WorkflowTodo() {
+  return _react().default.createElement(_client().SchemaComponent, {
+    components: {
+      NodeColumn,
+      WorkflowColumn,
+      UserColumn
+    },
+    schema: {
+      type: 'void',
+      name: (0, _client2().uid)(),
+      'x-component': 'div',
+      properties: {
+        actions: {
+          type: 'void',
+          'x-component': 'ActionBar',
+          'x-component-props': {
+            style: {
+              marginBottom: 16
+            }
+          },
+          properties: {
+            filter: {
+              type: 'void',
+              title: '{{ t("Filter") }}',
+              'x-action': 'filter',
+              'x-designer': 'Filter.Action.Designer',
+              'x-component': 'Filter.Action',
+              'x-component-props': {
+                icon: 'FilterOutlined',
+                useProps: '{{ useFilterActionProps }}'
+              },
+              'x-align': 'left'
+            },
+            refresher: {
+              type: 'void',
+              title: '{{ t("Refresh") }}',
+              'x-action': 'refresh',
+              'x-component': 'Action',
+              'x-designer': 'Action.Designer',
+              'x-component-props': {
+                icon: 'ReloadOutlined',
+                useProps: '{{ useRefreshActionProps }}'
+              },
+              'x-align': 'right'
+            }
+          }
+        },
+        table: {
+          type: 'array',
+          'x-component': 'TableV2',
+          'x-component-props': {
+            rowKey: 'id',
+            useProps: '{{ useTableBlockProps }}'
+          },
+          properties: {
+            node: {
+              type: 'void',
+              'x-decorator': 'TableV2.Column.Decorator',
+              'x-component': 'TableV2.Column',
+              title: `{{t("Task", { ns: "${_locale.NAMESPACE}" })}}`,
+              properties: {
+                node: {
+                  'x-component': 'NodeColumn',
+                  'x-read-pretty': true
+                }
+              }
+            },
+            workflow: {
+              type: 'void',
+              'x-decorator': 'TableV2.Column.Decorator',
+              'x-component': 'TableV2.Column',
+              title: `{{t("Workflow", { ns: "${_locale.NAMESPACE}" })}}`,
+              properties: {
+                workflow: {
+                  'x-component': 'WorkflowColumn',
+                  'x-read-pretty': true
+                }
+              }
+            },
+            createdAt: {
+              type: 'void',
+              'x-decorator': 'TableV2.Column.Decorator',
+              'x-component': 'TableV2.Column',
+              properties: {
+                createdAt: {
+                  type: 'number',
+                  'x-component': 'CollectionField',
+                  'x-read-pretty': true
+                }
+              }
+            },
+            user: {
+              type: 'void',
+              'x-decorator': 'TableV2.Column.Decorator',
+              'x-component': 'TableV2.Column',
+              title: `{{t("Assignee", { ns: "${_locale.NAMESPACE}" })}}`,
+              properties: {
+                user: {
+                  'x-component': 'UserColumn',
+                  'x-read-pretty': true
+                }
+              }
+            },
+            status: {
+              type: 'void',
+              'x-decorator': 'TableV2.Column.Decorator',
+              'x-component': 'TableV2.Column',
+              properties: {
+                status: {
+                  type: 'number',
+                  'x-component': 'CollectionField',
+                  'x-read-pretty': true
+                }
+              }
+            },
+            actions: {
+              type: 'void',
+              'x-decorator': 'TableV2.Column.Decorator',
+              'x-component': 'TableV2.Column',
+              title: '{{t("Actions")}}',
+              properties: {
+                view: {
+                  type: 'void',
+                  'x-component': 'Action.Link',
+                  title: '{{t("View")}}',
+                  properties: {
+                    drawer: {
+                      'x-component': 'WorkflowTodo.Drawer'
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  });
+}
+
+const ManualActionStatusContext = (0, _react().createContext)(null);
+
+function useManualActionStatusContext() {
+  return (0, _react().useContext)(ManualActionStatusContext);
+}
+
+function ManualActionStatusProvider({
+  value,
+  children
+}) {
+  return _react().default.createElement(ManualActionStatusContext.Provider, {
+    value: value
+  }, children);
+}
+
+function useSubmit() {
+  const api = (0, _client().useAPIClient)();
+
+  const _useActionContext = (0, _client().useActionContext)(),
+        setVisible = _useActionContext.setVisible;
+
+  const _useForm = (0, _react2().useForm)(),
+        values = _useForm.values,
+        submit = _useForm.submit;
+
+  const nextStatus = useManualActionStatusContext();
+
+  const _useTableBlockContext = (0, _client().useTableBlockContext)(),
+        service = _useTableBlockContext.service;
+
+  const _useRecord = (0, _client().useRecord)(),
+        id = _useRecord.id;
+
+  return {
+    run() {
+      return _asyncToGenerator(function* () {
+        yield submit();
+        yield api.resource('users_jobs').submit({
+          filterByTk: id,
+          values: {
+            status: nextStatus,
+            result: values
+          }
+        });
+        setVisible(false);
+        service.refresh();
+      })();
+    }
+
+  };
+}
+
+function useFlowRecordFromBlock(opts) {
+  var _execution$jobs;
+
+  const _useFieldSchema = (0, _react2().useFieldSchema)(),
+        dataSource = _useFieldSchema['x-context-datasource'];
+
+  const _useFlowContext = (0, _FlowContext.useFlowContext)(),
+        execution = _useFlowContext.execution;
+
+  let result = (0, _jsonTemplates().default)(dataSource)({
+    $context: execution === null || execution === void 0 ? void 0 : execution.context,
+    $jobsMapByNodeId: ((_execution$jobs = execution === null || execution === void 0 ? void 0 : execution.jobs) !== null && _execution$jobs !== void 0 ? _execution$jobs : []).reduce((map, job) => Object.assign(map, {
+      [job.nodeId]: job.result
+    }), {})
+  });
+  return (0, _client().useRequest)(() => {
+    return Promise.resolve({
+      data: result
+    });
+  }, opts);
+}
+
+function FlowContextProvider(props) {
+  const api = (0, _client().useAPIClient)();
+
+  const _useRecord2 = (0, _client().useRecord)(),
+        node = _useRecord2.node,
+        executionId = _useRecord2.executionId;
+
+  const _useState = (0, _react().useState)(null),
+        _useState2 = _slicedToArray(_useState, 2),
+        flowContext = _useState2[0],
+        setFlowContext = _useState2[1];
+
+  (0, _react().useEffect)(() => {
+    var _api$resource$get, _api$resource;
+
+    if (!executionId) {
+      return;
+    }
+
+    (_api$resource$get = (_api$resource = api.resource('executions')).get) === null || _api$resource$get === void 0 ? void 0 : _api$resource$get.call(_api$resource, {
+      filterByTk: executionId,
+      appends: ['workflow', 'workflow.nodes', 'jobs']
+    }).then(({
+      data
+    }) => {
+      var _data$data;
+
+      const _ref = (_data$data = data === null || data === void 0 ? void 0 : data.data) !== null && _data$data !== void 0 ? _data$data : {},
+            _ref$workflow = _ref.workflow,
+            _ref$workflow2 = _ref$workflow === void 0 ? {} : _ref$workflow,
+            _ref$workflow2$nodes = _ref$workflow2.nodes,
+            nodes = _ref$workflow2$nodes === void 0 ? [] : _ref$workflow2$nodes,
+            workflow = _objectWithoutProperties(_ref$workflow2, _excluded),
+            execution = _objectWithoutProperties(_ref, _excluded2);
+
+      (0, _utils.linkNodes)(nodes);
+      setFlowContext({
+        workflow,
+        nodes,
+        execution
+      });
+    });
+  }, [executionId]);
+
+  if (!flowContext) {
+    return null;
+  }
+
+  const nodes = (0, _.useAvailableUpstreams)(flowContext.nodes.find(item => item.id === node.id));
+  const nodeComponents = nodes.reduce((components, {
+    type
+  }) => Object.assign(components, _.instructions.get(type).components), {});
+  return _react().default.createElement(_FlowContext.FlowContext.Provider, {
+    value: flowContext
+  }, _react().default.createElement(_client().SchemaComponentOptions, {
+    components: _objectSpread({}, nodeComponents)
+  }, props.children));
+}
+
+WorkflowTodo.Drawer = function () {
+  var _node$config$schema, _node$title;
+
+  const ctx = (0, _react().useContext)(_client().SchemaComponentContext);
+
+  const _useRecord3 = (0, _client().useRecord)(),
+        id = _useRecord3.id,
+        node = _useRecord3.node,
+        workflow = _useRecord3.workflow,
+        status = _useRecord3.status,
+        result = _useRecord3.result,
+        updatedAt = _useRecord3.updatedAt;
+
+  const form = (0, _react().useMemo)(() => (0, _core().createForm)({
+    readPretty: Boolean(status),
+    initialValues: result
+  }), [result]);
+
+  const _ref2 = (_node$config$schema = node.config.schema) !== null && _node$config$schema !== void 0 ? _node$config$schema : {},
+        blocks = _ref2.blocks,
+        collection = _ref2.collection,
+        actions = _ref2.actions;
+
+  const statusOption = _constants.JobStatusOptionsMap[status];
+  const actionSchema = status ? {
+    date: {
+      type: 'void',
+      'x-component': 'time',
+      'x-component-props': {
+        className: (0, _css().css)`
+            margin-right: .5em;
+          `
+      },
+      'x-content': (0, _moment().default)(updatedAt).format('YYYY-MM-DD HH:mm:ss')
+    },
+    status: {
+      type: 'void',
+      'x-component': 'Tag',
+      'x-component-props': {
+        icon: statusOption.icon,
+        color: statusOption.color
+      },
+      'x-content': statusOption.label
+    }
+  } : actions;
+  return _react().default.createElement(_client().SchemaComponentContext.Provider, {
+    value: _objectSpread(_objectSpread({}, ctx), {}, {
+      designable: false
+    })
+  }, _react().default.createElement(_client().CollectionProvider, {
+    collection: collection
+  }, _react().default.createElement(_client().SchemaComponent, {
+    components: {
+      Tag: _antd().Tag,
+      ManualActionStatusProvider,
+      FlowContextProvider
+    },
+    schema: {
+      type: 'void',
+      name: `drawer-${id}-${status}`,
+      'x-decorator': 'Form',
+      'x-decorator-props': {
+        form
+      },
+      'x-component': 'Action.Drawer',
+      'x-component-props': {
+        className: 'nb-action-popup'
+      },
+      title: `${workflow.title} - ${(_node$title = node.title) !== null && _node$title !== void 0 ? _node$title : `#${node.id}`}`,
+      properties: {
+        tabs: {
+          type: 'void',
+          'x-decorator': 'FlowContextProvider',
+          'x-component': 'Tabs',
+          properties: blocks
+        },
+        footer: {
+          type: 'void',
+          'x-component': 'Action.Drawer.Footer',
+          properties: actionSchema
+        }
+      }
+    },
+    scope: {
+      useSubmit,
+      useFlowRecordFromBlock
+    }
+  })));
+};
+
+WorkflowTodo.Decorator = function ({
+  children
+}) {
+  const _useCollectionManager = (0, _client().useCollectionManager)(),
+        collections = _useCollectionManager.collections,
+        cm = _objectWithoutProperties(_useCollectionManager, _excluded3);
+
+  const blockProps = {
+    collection: 'users_jobs',
+    resource: 'users_jobs',
+    action: 'list',
+    params: {
+      pageSize: 20,
+      sort: ['-createdAt'],
+      appends: ['user', 'node', 'workflow'],
+      except: ['workflow.config']
+    },
+    rowKey: 'id',
+    showIndex: true,
+    dragSort: false
+  };
+  return _react().default.createElement(_client().CollectionManagerProvider, _objectSpread(_objectSpread({}, cm), {}, {
+    collections: [...collections, nodeCollection, workflowCollection, todoCollection]
+  }), _react().default.createElement(_client().TableBlockProvider, _objectSpread({}, blockProps), children));
+};

package/lib/client/nodes/manual/WorkflowTodoBlockInitializer.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare function WorkflowTodoBlockInitializer({ insert, ...props }: {
+    [x: string]: any;
+    insert: any;
+}): JSX.Element;