@zhubangyun/lowcode-core 1.1.0

package/es/utils/common/RestFormApi.js

@@ -0,0 +1,158 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { RestApi } from "./RestApi";
+export var RestFormApi = /*#__PURE__*/function (_RestApi) {
+  function RestFormApi(formName, options) {
+    var _this;
+    _this = _RestApi.call(this, "forms/" + formName, options) || this;
+    _this.initialized = false;
+    _this.schema = void 0;
+    return _this;
+  }
+  _inheritsLoose(RestFormApi, _RestApi);
+  var _proto = RestFormApi.prototype;
+  _proto.initialize = /*#__PURE__*/function () {
+    var _initialize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (this.initialized) {
+              _context.next = 8;
+              break;
+            }
+            _context.prev = 1;
+            //this.schema = await schemaCache.get(super.uri)
+            /*  this.schema = await PageUtils.schemaCache.lazyGet(this.title);
+              this.handler = new FormDataHandler(this.schema);*/
+            this.initialized = true;
+            _context.next = 8;
+            break;
+          case 5:
+            _context.prev = 5;
+            _context.t0 = _context["catch"](1);
+            throw _context.t0;
+          case 8:
+            return _context.abrupt("return", this.initialized);
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this, [[1, 5]]);
+    }));
+    function initialize() {
+      return _initialize.apply(this, arguments);
+    }
+    return initialize;
+  }();
+  _proto.search = /*#__PURE__*/function () {
+    var _search = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(params, page, pageSize) {
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (params === void 0) {
+              params = {};
+            }
+            if (page === void 0) {
+              page = 1;
+            }
+            if (pageSize === void 0) {
+              pageSize = 20;
+            }
+            _context2.next = 5;
+            return this.initialize();
+          case 5:
+            return _context2.abrupt("return", _RestApi.prototype.search.call(this, params, page, pageSize));
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function search(_x, _x2, _x3) {
+      return _search.apply(this, arguments);
+    }
+    return search;
+  }();
+  _proto.getById = /*#__PURE__*/function () {
+    var _getById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(id, options) {
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return this.initialize();
+          case 2:
+            return _context3.abrupt("return", _RestApi.prototype.getById.call(this, id, options));
+          case 3:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function getById(_x4, _x5) {
+      return _getById.apply(this, arguments);
+    }
+    return getById;
+  }();
+  _proto.create = /*#__PURE__*/function () {
+    var _create = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(data, options) {
+      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return this.initialize();
+          case 2:
+            return _context4.abrupt("return", _RestApi.prototype.create.call(this, data, options));
+          case 3:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function create(_x6, _x7) {
+      return _create.apply(this, arguments);
+    }
+    return create;
+  }();
+  _proto.update = /*#__PURE__*/function () {
+    var _update = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(id, data, options) {
+      return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.next = 2;
+            return this.initialize();
+          case 2:
+            return _context5.abrupt("return", _RestApi.prototype.update.call(this, id, data, options));
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this);
+    }));
+    function update(_x8, _x9, _x10) {
+      return _update.apply(this, arguments);
+    }
+    return update;
+  }();
+  _proto.deleteById = /*#__PURE__*/function () {
+    var _deleteById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(id, options) {
+      return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 2;
+            return this.initialize();
+          case 2:
+            return _context6.abrupt("return", _RestApi.prototype.deleteById.call(this, id, options));
+          case 3:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this);
+    }));
+    function deleteById(_x11, _x12) {
+      return _deleteById.apply(this, arguments);
+    }
+    return deleteById;
+  }();
+  return RestFormApi;
+}(RestApi);

package/es/utils/common/SubFormInstance.d.ts

@@ -0,0 +1,26 @@
+import { FormInstance } from "antd/lib";
+import { NamePath, StoreValue } from "antd/es/form/interface";
+declare type NamePaths = (string | number)[];
+export declare class SubFormInstance implements FormInstance {
+    parentForm: FormInstance;
+    namePath: NamePaths;
+    constructor(form: FormInstance, namePath: NamePaths);
+    overwritePathName(name: NamePath): any[];
+    overwriteFields(fields: any[]): any[];
+    getFieldError(name: NamePath): string[];
+    getFieldValue(name: NamePath): StoreValue;
+    getFieldWarning(name: NamePath): string[];
+    getFieldsError(nameList: NamePath[] | undefined): any[];
+    getFieldsValue(nameList?: NamePath[] | true, filterFunc?: (meta: any) => boolean): any;
+    isFieldTouched(name: NamePath): boolean;
+    isFieldValidating(name: NamePath): boolean;
+    isFieldsTouched(): boolean;
+    isFieldsValidating(nameList: NamePath[]): boolean;
+    resetFields(fields: NamePath[] | undefined): void;
+    setFieldValue(name: NamePath, value: any): void;
+    setFields(fields: any[]): void;
+    setFieldsValue(values: any): void;
+    submit(): void;
+    validateFields(nameList: NamePath[] | undefined): Promise<any>;
+}
+export {};

package/es/utils/common/SubFormInstance.js

@@ -0,0 +1,100 @@
+import _extends from "@babel/runtime/helpers/extends";
+export var SubFormInstance = /*#__PURE__*/function () {
+  function SubFormInstance(form, namePath) {
+    this.parentForm = void 0;
+    this.namePath = void 0;
+    this.parentForm = form;
+    this.namePath = namePath;
+  }
+  var _proto = SubFormInstance.prototype;
+  _proto.overwritePathName = function overwritePathName(name) {
+    if (Array.isArray(name)) {
+      return [].concat(this.namePath, name);
+    } else {
+      return [].concat(this.namePath, [name]);
+    }
+  };
+  _proto.overwriteFields = function overwriteFields(fields) {
+    var _this = this;
+    return fields === null || fields === void 0 ? void 0 : fields.map(function (field) {
+      return _extends({}, field, {
+        name: _this.overwritePathName(field.name)
+      });
+    });
+  };
+  _proto.getFieldError = function getFieldError(name) {
+    return this.parentForm.getFieldError(this.overwritePathName(name));
+  };
+  _proto.getFieldValue = function getFieldValue(name) {
+    return this.parentForm.getFieldValue(this.overwritePathName(name));
+  };
+  _proto.getFieldWarning = function getFieldWarning(name) {
+    return this.parentForm.getFieldWarning(this.overwritePathName(name));
+  }
+
+  // @ts-ignore
+  ;
+  _proto.getFieldsError = function getFieldsError(nameList) {
+    var _this2 = this;
+    return this.parentForm.getFieldsError(nameList === null || nameList === void 0 ? void 0 : nameList.map(function (name) {
+      return _this2.overwritePathName(name);
+    }));
+  }
+
+  // @ts-ignore
+  ;
+  _proto.getFieldsValue = function getFieldsValue(nameList, filterFunc) {
+    var values = _extends({}, this.parentForm.getFieldValue(this.namePath));
+    values.parent = this.parentForm.getFieldsValue(true);
+    return values;
+  };
+  _proto.isFieldTouched = function isFieldTouched(name) {
+    return this.parentForm.isFieldTouched(this.overwritePathName(name));
+  };
+  _proto.isFieldValidating = function isFieldValidating(name) {
+    return this.parentForm.isFieldValidating(this.overwritePathName(name));
+  };
+  _proto.isFieldsTouched = function isFieldsTouched() {
+    return this.parentForm.isFieldsTouched();
+  };
+  // @ts-ignore
+  _proto.isFieldsValidating = function isFieldsValidating(nameList) {
+    var _this3 = this;
+    return this.parentForm.isFieldsValidating(nameList.map(function (name) {
+      return _this3.overwritePathName(name);
+    }));
+  };
+  _proto.resetFields = function resetFields(fields) {
+    if (Array.isArray(fields)) {
+      // @ts-ignore
+      this.parentForm.resetFields(this.overwriteFields(fields));
+    } else {
+      this.parentForm.resetFields();
+    }
+  };
+  _proto.setFieldValue = function setFieldValue(name, value) {
+    return this.parentForm.setFieldValue(this.overwritePathName(name), value);
+  };
+  _proto.setFields = function setFields(fields) {
+    this.parentForm.setFields(this.overwriteFields(fields));
+  };
+  _proto.setFieldsValue = function setFieldsValue(values) {
+    var _this4 = this;
+    if (!values) return;
+    //删除父值
+    delete values.parent;
+    Object.keys(values).forEach(function (name) {
+      return _this4.parentForm.setFieldValue(_this4.overwritePathName(name), values[name]);
+    });
+  };
+  _proto.submit = function submit() {
+    this.parentForm.submit();
+  }
+
+  // @ts-ignore
+  ;
+  _proto.validateFields = function validateFields(nameList) {
+    return this.parentForm.validateFields(nameList);
+  };
+  return SubFormInstance;
+}();

package/es/utils/common/UserInfo.d.ts

@@ -0,0 +1,9 @@
+export interface UserInfo {
+    userId: string;
+    userName: string;
+    staffId: string;
+    staffName: string;
+    roleIds: string[];
+    deptIds: string[];
+}
+export declare function loadUserInfo(): Promise<UserInfo>;

package/es/utils/common/UserInfo.js

@@ -0,0 +1,19 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export function loadUserInfo() {
+  return _loadUserInfo.apply(this, arguments);
+}
+function _loadUserInfo() {
+  _loadUserInfo = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", {});
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _loadUserInfo.apply(this, arguments);
+}

package/es/utils/common/index.d.ts

@@ -0,0 +1,7 @@
+import { ClientCache } from "./ClientCache";
+export { RestApi } from "./RestApi";
+export { RestFormApi } from "./RestFormApi";
+export { ClientCache } from "./ClientCache";
+export { loadPlugins } from "./LoadPlugins";
+export declare function uuid(prefix?: string, separator?: string): string;
+export declare const schemaCache: ClientCache;

package/es/utils/common/index.js

@@ -0,0 +1,39 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { v4 } from "uuid";
+import { ClientCache } from "./ClientCache";
+import { request } from "../api";
+export { RestApi } from "./RestApi";
+export { RestFormApi } from "./RestFormApi";
+export { ClientCache } from "./ClientCache";
+export { loadPlugins } from "./LoadPlugins";
+export function uuid(prefix, separator) {
+  return [prefix, separator, v4()].filter(function (v) {
+    return !!v;
+  }).join("");
+}
+export var schemaCache = new ClientCache({
+  name: "schema",
+  loadData: function () {
+    var _loadData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(name) {
+      var res;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return request.get("schemas/" + name + ".json");
+          case 2:
+            res = _context.sent;
+            return _context.abrupt("return", res.data);
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function loadData(_x) {
+      return _loadData.apply(this, arguments);
+    }
+    return loadData;
+  }()
+});

package/es/utils/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./api";
+export * from "./common";
+export * from "./lowcode";
+import * as common from "./common";
+import * as api from "./api";
+import * as lowcode from "./lowcode";
+declare const _default: {
+    uuid(prefix?: string, separator?: string): string;
+    RestApi: typeof common.RestApi;
+    RestFormApi: typeof common.RestFormApi;
+    ClientCache: typeof common.ClientCache;
+    loadPlugins: typeof common.loadPlugins;
+    schemaCache: common.ClientCache;
+    api: typeof api;
+    lowcode: typeof lowcode;
+};
+export default _default;

package/es/utils/index.js

@@ -0,0 +1,11 @@
+import _extends from "@babel/runtime/helpers/extends";
+export * from "./api";
+export * from "./common";
+export * from "./lowcode";
+import * as common from "./common";
+import * as api from "./api";
+import * as lowcode from "./lowcode";
+export default _extends({
+  api: api,
+  lowcode: lowcode
+}, common);

package/es/utils/lowcode/index.d.ts

@@ -0,0 +1 @@
+export { parseAssets } from "./parseAssets";

package/es/utils/lowcode/index.js

@@ -0,0 +1 @@
+export { parseAssets } from "./parseAssets";

package/es/utils/lowcode/parseAssets.d.ts

@@ -0,0 +1,3 @@
+export declare function parseAssets(assets: any): Promise<{
+    components: any;
+}>;

package/es/utils/lowcode/parseAssets.js

@@ -0,0 +1,185 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { AssetLoader, buildComponents } from '@zhubangyun/lowcode-utils';
+import ReactRenderer from '@zhubangyun/lowcode-renderer-core';
+import React, { createElement } from 'react';
+function genLowcodeComp(schema, components) {
+  return /*#__PURE__*/function (_React$Component) {
+    function LowcodeComp() {
+      return _React$Component.apply(this, arguments) || this;
+    }
+    _inheritsLoose(LowcodeComp, _React$Component);
+    var _proto = LowcodeComp.prototype;
+    _proto.render = function render() {
+      return /*#__PURE__*/createElement(ReactRenderer, _extends({}, this.props, {
+        schema: schema,
+        components: components,
+        designMode: ''
+      }));
+    };
+    return LowcodeComp;
+  }(React.Component);
+}
+export function parseAssets(_x) {
+  return _parseAssets.apply(this, arguments);
+}
+function _parseAssets() {
+  _parseAssets = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(assets) {
+    var rawComponents, packages, libraryAsset, libraryMap, packagesMap, assetLoader, newComponents, componentDescriptions, remoteComponentDescriptions, lowcodeComponentsArray, proCodeComponentsMap, genLowCodeComponentsMap, components, lowCodeComponents;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          genLowCodeComponentsMap = function _genLowCodeComponents(components) {
+            var lowcodeComponentsMap = {};
+            lowcodeComponentsArray.forEach(function (lowcode) {
+              var _lowcode$reference, _packagesMap$id;
+              var id = (_lowcode$reference = lowcode.reference) === null || _lowcode$reference === void 0 ? void 0 : _lowcode$reference.id;
+              var schema = (_packagesMap$id = packagesMap[id]) === null || _packagesMap$id === void 0 ? void 0 : _packagesMap$id.schema;
+              lowcodeComponentsMap[lowcode.componentName] = genLowcodeComp(schema, _extends({}, components, lowcodeComponentsMap));
+            });
+            return lowcodeComponentsMap;
+          };
+          rawComponents = assets.components, packages = assets.packages;
+          libraryAsset = [];
+          libraryMap = {};
+          packagesMap = {};
+          packages.forEach(function (pkg) {
+            var _package = pkg["package"],
+              library = pkg.library,
+              urls = pkg.urls,
+              renderUrls = pkg.renderUrls,
+              id = pkg.id;
+            if (_package) {
+              libraryMap[id || _package] = library;
+            }
+            packagesMap[id || _package] = pkg;
+            if (renderUrls) {
+              libraryAsset.push(renderUrls);
+            } else if (urls) {
+              libraryAsset.push(urls);
+            }
+          });
+          assetLoader = new AssetLoader();
+          _context2.next = 9;
+          return assetLoader.load(libraryAsset);
+        case 9:
+          newComponents = rawComponents;
+          if (!(rawComponents && rawComponents.length)) {
+            _context2.next = 18;
+            break;
+          }
+          componentDescriptions = [];
+          remoteComponentDescriptions = [];
+          rawComponents.forEach(function (component) {
+            if (!component) {
+              return;
+            }
+            if (component.exportName && component.url) {
+              remoteComponentDescriptions.push(component);
+            } else {
+              componentDescriptions.push(component);
+            }
+          });
+          newComponents = [].concat(componentDescriptions);
+
+          // 如果有远程组件描述协议，则自动加载并补充到资产包中，同时出发 designer.incrementalAssetsReady 通知组件面板更新数据
+          if (!(remoteComponentDescriptions && remoteComponentDescriptions.length)) {
+            _context2.next = 18;
+            break;
+          }
+          _context2.next = 18;
+          return Promise.all(remoteComponentDescriptions.map( /*#__PURE__*/function () {
+            var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(component) {
+              var exportName, url, npm, setAssetsComponent, setArrayAssets;
+              return _regeneratorRuntime.wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    setArrayAssets = function _setArrayAssets(value, preExportName, preSubName) {
+                      if (preExportName === void 0) {
+                        preExportName = '';
+                      }
+                      if (preSubName === void 0) {
+                        preSubName = '';
+                      }
+                      value.forEach(function (d, i) {
+                        var exportName = [preExportName, i.toString()].filter(function (d) {
+                          return !!d;
+                        }).join('.');
+                        var subName = [preSubName, i.toString()].filter(function (d) {
+                          return !!d;
+                        }).join('.');
+                        Array.isArray(d) ? setArrayAssets(d, exportName, subName) : setAssetsComponent(d, {
+                          exportName: exportName,
+                          subName: subName
+                        });
+                      });
+                    };
+                    setAssetsComponent = function _setAssetsComponent(component, extraNpmInfo) {
+                      if (extraNpmInfo === void 0) {
+                        extraNpmInfo = {};
+                      }
+                      var components = component.components;
+                      if (Array.isArray(components)) {
+                        components.forEach(function (d) {
+                          newComponents = newComponents.concat(_extends({
+                            npm: _extends({}, npm, extraNpmInfo)
+                          }, d) || []);
+                        });
+                        return;
+                      }
+                      newComponents = newComponents.concat(_extends({
+                        npm: _extends({}, npm, extraNpmInfo)
+                      }, component.components) || []);
+                      // assets.componentList = assets.componentList.concat(component.componentList || []);
+                    };
+                    exportName = component.exportName, url = component.url, npm = component.npm;
+                    _context.next = 5;
+                    return new AssetLoader().load(url);
+                  case 5:
+                    if (window[exportName]) {
+                      if (Array.isArray(window[exportName])) {
+                        setArrayAssets(window[exportName]);
+                      } else {
+                        setAssetsComponent(window[exportName]);
+                      }
+                    }
+                    return _context.abrupt("return", window[exportName]);
+                  case 7:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            }));
+            return function (_x2) {
+              return _ref.apply(this, arguments);
+            };
+          }()));
+        case 18:
+          lowcodeComponentsArray = [];
+          proCodeComponentsMap = newComponents.reduce(function (acc, cur) {
+            if ((cur.devMode || '').toLowerCase() === 'lowcode') {
+              lowcodeComponentsArray.push(cur);
+            } else {
+              acc[cur.componentName] = _extends({}, cur.reference || cur.npm, {
+                componentName: cur.componentName
+              });
+            }
+            return acc;
+          }, {});
+          components = buildComponents(libraryMap, proCodeComponentsMap, function (schema) {
+            return null;
+          });
+          lowCodeComponents = genLowCodeComponentsMap(components);
+          return _context2.abrupt("return", {
+            components: _extends({}, components, lowCodeComponents)
+          });
+        case 23:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _parseAssets.apply(this, arguments);
+}

package/lib/components/layout/index.d.ts

@@ -0,0 +1,34 @@
+import { CSSProperties, ReactNode } from "react";
+import "./index.less";
+export declare function Layout(props: {
+    header?: ReactNode;
+    footer?: ReactNode;
+    left?: ReactNode;
+    right?: ReactNode;
+    children?: ReactNode;
+    styles?: {
+        header?: CSSProperties;
+        footer?: CSSProperties;
+        left?: CSSProperties;
+        right?: CSSProperties;
+        content?: CSSProperties;
+    };
+}): import("react").JSX.Element;
+export declare function LayoutVertical(props: {
+    header?: ReactNode;
+    footer?: ReactNode;
+    children?: ReactNode;
+    styles?: {
+        header?: CSSProperties;
+        footer?: CSSProperties;
+    };
+}): import("react").JSX.Element;
+export declare function LayoutHorizontal(props: {
+    left?: ReactNode;
+    right?: ReactNode;
+    children?: ReactNode;
+    styles?: {
+        left?: CSSProperties;
+        right?: CSSProperties;
+    };
+}): import("react").JSX.Element;