@nocobase/client 0.7.0-alpha.9 → 0.7.1-alpha.6

package/es/schema-component/antd/form-v2/index.js

@@ -0,0 +1,5 @@
+import { Form as FormV2 } from './Form';
+import { DetailsDesigner, FormDesigner, ReadPrettyFormDesigner } from './Form.Designer';
+FormV2.Designer = FormDesigner;
+FormV2.ReadPrettyDesigner = ReadPrettyFormDesigner;
+export { FormV2, DetailsDesigner };

package/es/schema-component/antd/formula-input/Compute.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Compute: React.ForwardRefExoticComponent<Pick<Partial<any>, string | number | symbol> & React.RefAttributes<unknown>>;
+export default Compute;

package/es/schema-component/antd/formula-input/Compute.js

@@ -0,0 +1,55 @@
+var _excluded = ["onChange"];
+
+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; }
+
+import { onFormValuesChange } from '@formily/core';
+import { connect, mapReadPretty, useFieldSchema, useFormEffects } from '@formily/react';
+import { InputNumber } from 'antd';
+import _ from 'lodash';
+import * as math from 'mathjs';
+import React from 'react';
+import { useCollection } from '../../../collection-manager/hooks';
+import { ReadPretty } from '../input-number/ReadPretty';
+
+var AntdCompute = function AntdCompute(props) {
+  var onChange = props.onChange,
+      others = _objectWithoutProperties(props, _excluded);
+
+  var _useCollection = useCollection(),
+      getField = _useCollection.getField;
+
+  var fieldSchema = useFieldSchema();
+  var options = getField(fieldSchema.name);
+  var expression = options.expression;
+  useFormEffects(function () {
+    onFormValuesChange(function (form) {
+      var scope = _.cloneDeep(form.values);
+
+      var result;
+
+      try {
+        result = math.evaluate(expression, scope);
+        result = math.round(result, 9);
+      } catch (_unused) {}
+
+      if (onChange) {
+        onChange(result);
+      }
+    });
+  });
+  return /*#__PURE__*/React.createElement(InputNumber, _objectSpread(_objectSpread({}, others), {}, {
+    readOnly: true,
+    stringMode: true
+  }));
+};
+
+export var Compute = connect(AntdCompute, mapReadPretty(ReadPretty));
+export default Compute;

package/es/schema-component/antd/formula-input/FormulaInput.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const FormulaInput: React.ForwardRefExoticComponent<Pick<Partial<any>, string | number | symbol> & React.RefAttributes<unknown>>;
+export default FormulaInput;

package/es/schema-component/antd/formula-input/FormulaInput.js

@@ -0,0 +1,173 @@
+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); }); }; }
+
+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; }
+
+import { onFormSubmitValidateStart } from '@formily/core';
+import { connect, mapProps, useField, useFormEffects } from '@formily/react';
+import { Menu, Dropdown } from 'antd';
+import React, { useEffect, useRef, useState } from 'react';
+import ContentEditable from 'react-contenteditable';
+import { useTranslation } from 'react-i18next';
+import * as math from 'mathjs';
+
+var AntdFormulaInput = function AntdFormulaInput(props) {
+  var value = props.value,
+      onChange = props.onChange,
+      supports = props.supports,
+      useCurrentFields = props.useCurrentFields;
+  var field = useField();
+
+  var _useTranslation = useTranslation(),
+      t = _useTranslation.t;
+
+  var fields = useCurrentFields();
+  var inputRef = useRef();
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      dropdownVisible = _useState2[0],
+      setDropdownVisible = _useState2[1];
+
+  var _useState3 = useState(null),
+      _useState4 = _slicedToArray(_useState3, 2),
+      formula = _useState4[0],
+      setFormula = _useState4[1];
+
+  var _useState5 = useState(null),
+      _useState6 = _slicedToArray(_useState5, 2),
+      html = _useState6[0],
+      setHtml = _useState6[1];
+
+  var numColumns = new Map();
+  var scope = {};
+  fields.filter(function (field) {
+    return supports.includes(field.interface);
+  }).forEach(function (field) {
+    numColumns.set(field.name, field.uiSchema.title);
+    scope[field.name] = 1;
+  });
+  var keys = Array.from(numColumns.keys());
+  var initHtml;
+
+  if (value) {
+    initHtml = value;
+    numColumns.forEach(function (value, key) {
+      initHtml = initHtml.replaceAll(key, "<span contentEditable=\"false\" style=\"border: 1px solid #aaa; padding: 2px 5px;\">".concat(value, "</span>"));
+    });
+  }
+
+  useEffect(function () {
+    if (onChange && formula) {
+      var v = formula || '';
+      numColumns.forEach(function (value, key) {
+        v = v.replaceAll(value, key);
+      });
+
+      if (v != value) {
+        onChange(v);
+      }
+    }
+  }, [formula]);
+  var menu = /*#__PURE__*/React.createElement(Menu, {
+    onClick: function () {
+      var _onClick = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(args) {
+        var replaceFormula, replaceHtml;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                replaceFormula = formula.replace('@', numColumns.get(args.key));
+                replaceHtml = html.replace('@', "<span contentEditable=\"false\" style=\"border: 1px solid #aaa; padding: 2px 5px;\">".concat(numColumns.get(args.key), "</span>"));
+                setFormula(replaceFormula);
+                setHtml(replaceHtml);
+                setDropdownVisible(false);
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function onClick(_x) {
+        return _onClick.apply(this, arguments);
+      }
+
+      return onClick;
+    }()
+  }, keys.map(function (key) {
+    return /*#__PURE__*/React.createElement(Menu.Item, {
+      key: key
+    }, numColumns.get(key));
+  }));
+
+  var handleChange = function handleChange(e) {
+    var current = inputRef.current;
+    setFormula(e.currentTarget.textContent);
+    setHtml(current.innerHTML);
+
+    if (e.currentTarget.textContent == '' && onChange) {
+      onChange(null);
+    }
+  };
+
+  var handleKeyDown = function handleKeyDown(e) {
+    var key = e.key;
+
+    switch (key) {
+      case 'Enter':
+        e.preventDefault();
+        break;
+
+      case '@':
+      case 'Process':
+        setDropdownVisible(true);
+        break;
+
+      default:
+        setDropdownVisible(false);
+        break;
+    }
+  };
+
+  useFormEffects(function () {
+    onFormSubmitValidateStart(function () {
+      try {
+        math.evaluate(field.value, scope);
+        field.feedbacks = [];
+      } catch (_unused) {
+        field.setFeedback({
+          type: 'error',
+          code: 'FormulaError',
+          messages: [t('Formula error.')]
+        });
+      }
+    });
+  });
+  return /*#__PURE__*/React.createElement(Dropdown, {
+    overlay: menu,
+    visible: dropdownVisible
+  }, /*#__PURE__*/React.createElement(ContentEditable, {
+    innerRef: inputRef,
+    className: "ant-input",
+    onChange: handleChange,
+    onKeyDown: handleKeyDown,
+    html: html || initHtml || ''
+  }));
+};
+
+export var FormulaInput = connect(AntdFormulaInput, mapProps({}));
+export default FormulaInput;

package/es/schema-component/antd/formula-input/index.d.ts

@@ -0,0 +1 @@
+export declare const Formula: any;

package/es/schema-component/antd/formula-input/index.js

@@ -0,0 +1,7 @@
+import { Compute } from './Compute';
+import { FormulaInput } from './FormulaInput';
+export var Formula = function Formula() {
+  return null;
+};
+Formula.Expression = FormulaInput;
+Formula.Result = Compute;

package/es/schema-component/antd/g2plot/G2Plot.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare type ReactG2PlotProps<O> = {
+    readonly className?: string;
+    readonly plot: any;
+    readonly config: O;
+};
+export declare const G2PlotRenderer: React.ForwardRefExoticComponent<ReactG2PlotProps<unknown> & React.RefAttributes<unknown>>;
+export declare const G2Plot: any;

package/es/schema-component/antd/g2plot/G2Plot.js

@@ -0,0 +1,123 @@
+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; }
+
+import { Area, Bar, Column, Line, Pie } from '@antv/g2plot';
+import { observer, useField } from '@formily/react';
+import { Spin } from 'antd';
+import cls from 'classnames';
+import React, { forwardRef, useEffect, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useAPIClient } from '../../../api-client';
+import { G2PlotDesigner } from './G2PlotDesigner';
+var plots = {
+  Area: Area,
+  Column: Column,
+  Line: Line,
+  Pie: Pie,
+  Bar: Bar
+};
+export var G2PlotRenderer = /*#__PURE__*/forwardRef(function (props, ref) {
+  var className = props.className,
+      plot = props.plot,
+      config = props.config;
+  var containerRef = useRef(undefined);
+  var plotRef = useRef(undefined);
+
+  function syncRef(source, target) {
+    if (typeof target === 'function') {
+      target(source.current);
+    } else if (target) {
+      target.current = source.current;
+    }
+  }
+
+  function renderPlot() {
+    if (plotRef.current) {
+      plotRef.current.update(config);
+    } else {
+      plotRef.current = new plot(containerRef.current, config);
+      plotRef.current.render();
+    }
+
+    syncRef(plotRef, ref);
+  }
+
+  function destoryPlot() {
+    if (plotRef.current) {
+      plotRef.current.destroy();
+      plotRef.current = undefined;
+    }
+  }
+
+  useEffect(function () {
+    renderPlot();
+    return function () {
+      return destoryPlot();
+    };
+  }, [config, plot]);
+  return /*#__PURE__*/React.createElement("div", {
+    className: cls(['g2plot', className]),
+    ref: containerRef
+  });
+});
+export var G2Plot = observer(function (props) {
+  var _field$data;
+
+  var plot = props.plot,
+      config = props.config;
+  var field = useField();
+
+  var _useTranslation = useTranslation(),
+      t = _useTranslation.t;
+
+  var api = useAPIClient();
+  useEffect(function () {
+    field.data = field.data || {};
+    field.data.loading = true;
+    var fn = config === null || config === void 0 ? void 0 : config.data;
+
+    if (typeof fn === 'function') {
+      var result = fn.bind({
+        api: api
+      })();
+
+      if (result === null || result === void 0 ? void 0 : result.then) {
+        result.then(function (data) {
+          if (Array.isArray(data)) {
+            field.componentProps.config.data = data;
+          }
+
+          field.data.loading = false;
+        });
+      } else {
+        field.data.loading = false;
+      }
+    } else {
+      field.data.loading = false;
+    }
+  }, []);
+
+  if (!plot || !config) {
+    return /*#__PURE__*/React.createElement("div", {
+      style: {
+        opacity: 0.3
+      }
+    }, t('In configuration'), "...");
+  }
+
+  if ((field === null || field === void 0 ? void 0 : (_field$data = field.data) === null || _field$data === void 0 ? void 0 : _field$data.loading) !== false) {
+    return /*#__PURE__*/React.createElement(Spin, null);
+  }
+
+  return /*#__PURE__*/React.createElement("div", null, field.title && /*#__PURE__*/React.createElement("h2", null, field.title), /*#__PURE__*/React.createElement(G2PlotRenderer, {
+    plot: plots[plot],
+    config: _objectSpread(_objectSpread({}, config), {}, {
+      data: Array.isArray(config === null || config === void 0 ? void 0 : config.data) ? config.data : []
+    })
+  }));
+});
+G2Plot.Designer = G2PlotDesigner;
+G2Plot.plots = plots;

package/es/schema-component/antd/g2plot/G2PlotDesigner.d.ts

@@ -0,0 +1 @@
+export declare const G2PlotDesigner: () => JSX.Element;

package/es/schema-component/antd/g2plot/G2PlotDesigner.js

@@ -0,0 +1,127 @@
+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); }); }; }
+
+import { useField, useFieldSchema } from '@formily/react';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { useAPIClient } from '../../../api-client';
+import { GeneralSchemaDesigner, SchemaSettings } from '../../../schema-settings';
+import { useCompile, useDesignable } from '../../hooks';
+var validateJSON = {
+  validator: "{{(value, rule)=> {\n    if (!value) {\n      return '';\n    }\n    try {\n      const val = JSON.parse(value);\n      if(!isNaN(val)) {\n        return false;\n      }\n      return true;\n    } catch(error) {\n      console.error(error);\n      return false;\n    }\n  }}}",
+  message: '{{t("Invalid JSON format")}}'
+};
+export var G2PlotDesigner = function G2PlotDesigner() {
+  var _fieldSchema$xCompon, _fieldSchema$xCompon2, _fieldSchema$xCompon3;
+
+  var _useTranslation = useTranslation(),
+      t = _useTranslation.t;
+
+  var _useDesignable = useDesignable(),
+      dn = _useDesignable.dn;
+
+  var fieldSchema = useFieldSchema();
+  var field = useField();
+  var compile = useCompile();
+  var api = useAPIClient();
+  return /*#__PURE__*/React.createElement(GeneralSchemaDesigner, null, /*#__PURE__*/React.createElement(SchemaSettings.ModalItem, {
+    title: t('Edit chart'),
+    schema: {
+      type: 'object',
+      title: t('Edit chart'),
+      properties: {
+        title: {
+          title: t('Chart title'),
+          type: 'string',
+          default: fieldSchema.title,
+          'x-decorator': 'FormItem',
+          'x-component': 'Input'
+        },
+        plot: {
+          title: t('Chart type'),
+          type: 'string',
+          default: fieldSchema === null || fieldSchema === void 0 ? void 0 : (_fieldSchema$xCompon = fieldSchema['x-component-props']) === null || _fieldSchema$xCompon === void 0 ? void 0 : _fieldSchema$xCompon.plot,
+          'x-decorator': 'FormItem',
+          'x-component': 'Input',
+          'x-disabled': !!(fieldSchema === null || fieldSchema === void 0 ? void 0 : (_fieldSchema$xCompon2 = fieldSchema['x-component-props']) === null || _fieldSchema$xCompon2 === void 0 ? void 0 : _fieldSchema$xCompon2.plot)
+        },
+        config: {
+          title: t('Chart config'),
+          type: 'string',
+          default: JSON.stringify(fieldSchema === null || fieldSchema === void 0 ? void 0 : (_fieldSchema$xCompon3 = fieldSchema['x-component-props']) === null || _fieldSchema$xCompon3 === void 0 ? void 0 : _fieldSchema$xCompon3.config, null, 2),
+          'x-decorator': 'FormItem',
+          'x-component': 'Input.TextArea',
+          'x-component-props': {
+            autoSize: {
+              minRows: 8,
+              maxRows: 16
+            }
+          },
+          'x-validator': validateJSON
+        }
+      }
+    },
+    // {{ fetchData(api, { url: 'chartData:get' }) }}
+    onSubmit: function () {
+      var _onSubmit = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(_ref) {
+        var plot, title, config, conf, fn, result;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                plot = _ref.plot, title = _ref.title, config = _ref.config;
+                field.title = compile(title);
+                field.componentProps.plot = plot;
+                conf = compile(JSON.parse(config));
+                fn = conf === null || conf === void 0 ? void 0 : conf.data;
+
+                if (typeof fn === 'function') {
+                  result = fn.bind({
+                    api: api
+                  })();
+
+                  if (result === null || result === void 0 ? void 0 : result.then) {
+                    result.then(function (data) {
+                      if (Array.isArray(data)) {
+                        field.componentProps.config.data = data;
+                      }
+                    });
+                  }
+                } else {
+                  field.componentProps.config = conf;
+                }
+
+                fieldSchema.title = title;
+                fieldSchema['x-component-props']['plot'] = plot;
+                fieldSchema['x-component-props']['config'] = JSON.parse(config);
+                dn.emit('patch', {
+                  schema: {
+                    title: title,
+                    'x-uid': fieldSchema['x-uid'],
+                    'x-component-props': fieldSchema['x-component-props']
+                  }
+                });
+                dn.refresh();
+
+              case 11:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function onSubmit(_x) {
+        return _onSubmit.apply(this, arguments);
+      }
+
+      return onSubmit;
+    }()
+  }), /*#__PURE__*/React.createElement(SchemaSettings.Divider, null), /*#__PURE__*/React.createElement(SchemaSettings.Remove, {
+    removeParentsIfNoChildren: true,
+    breakRemoveOn: {
+      'x-component': 'Grid'
+    }
+  }));
+};

package/es/schema-component/antd/g2plot/index.d.ts

@@ -0,0 +1 @@
+export * from './G2Plot';

package/es/schema-component/antd/g2plot/index.js

@@ -0,0 +1 @@
+export * from './G2Plot';

package/es/schema-component/antd/grid/Block.js

@@ -0,0 +1,15 @@
+import { observer, useFieldSchema } from '@formily/react';
+import React from 'react';
+import { DragHandler } from '../../';
+export var Block = observer(function (props) {
+  var fieldSchema = useFieldSchema();
+  return /*#__PURE__*/React.createElement("div", {
+    style: {
+      marginBottom: 20,
+      padding: '0 20px',
+      height: 50,
+      lineHeight: '50px',
+      background: '#f1f1f1'
+    }
+  }, "Block ", fieldSchema.title, /*#__PURE__*/React.createElement(DragHandler, null));
+});

package/es/schema-component/antd/grid/Grid.d.ts

@@ -0,0 +1,3 @@
+export declare const useGridContext: () => any;
+export declare const useGridRowContext: () => any;
+export declare const Grid: any;