@zhubangyun/lowcode-core 5.3.132 → 5.3.181

package/es/utils/common/index.js

@@ -1,36 +1,7 @@
-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 { 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/{common/RestFormApi.d.ts → form/form.api.d.ts}

@@ -1,12 +1,17 @@
-import { BaseRequestOptions, RestApi, RestApiOptions } from "./RestApi";
+import { BaseRequestOptions, RestApi } from "../api/RestApi";
+import { AxiosRequestConfig } from "axios";
 export declare class RestFormApi<DataType> extends RestApi<DataType> {
+    private readonly formId;
+    private readonly mock;
     private initialized;
     private schema;
-    constructor(formName: string, options: RestApiOptions);
-    initialize(): Promise<true>;
-    search(params?: Record<string, any>, page?: number, pageSize?: number): Promise<any>;
+    constructor(formId: string, mock?: boolean);
+    initialize(): Promise<boolean>;
+    search(params?: Record<string, any>, page?: number, pageSize?: number): Promise<import("../api/RestApi").ManyResult<DataType>>;
     getById(id: string, options?: BaseRequestOptions<DataType>): Promise<any>;
+    save(data: DataType, options?: BaseRequestOptions<DataType>): Promise<any>;
     create(data: DataType, options?: BaseRequestOptions<DataType>): Promise<any>;
     update(id: string, data: DataType, options?: BaseRequestOptions<DataType>): Promise<any>;
     deleteById(id: string, options?: BaseRequestOptions<DataType>): Promise<any>;
+    handleRequestConfig(config: AxiosRequestConfig): void;
 }

package/es/utils/{common/RestFormApi.js → form/form.api.js}

@@ -1,13 +1,18 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-import { RestApi } from "./RestApi";
+import { RestApi } from "../api/RestApi";
+import { getSchema } from "../api";
 export var RestFormApi = /*#__PURE__*/function (_RestApi) {
-  function RestFormApi(formName, options) {
+  function RestFormApi(formId, mock) {
     var _this;
-    _this = _RestApi.call(this, "forms/" + formName, options) || this;
+    _this = _RestApi.call(this, "forms", {}) || this;
+    _this.formId = void 0;
+    _this.mock = void 0;
     _this.initialized = false;
     _this.schema = void 0;
+    _this.formId = formId;
+    _this.mock = !!mock;
     return _this;
   }
   _inheritsLoose(RestFormApi, _RestApi);
@@ -17,28 +22,35 @@ export var RestFormApi = /*#__PURE__*/function (_RestApi) {
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            if (this.initialized) {
-              _context.next = 8;
+            if (!this.initialized) {
+              _context.next = 4;
               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;
+            return _context.abrupt("return", true);
+          case 4:
+            _context.prev = 4;
+            _context.next = 7;
+            return getSchema(this.formId, this.mock);
+          case 7:
+            this.schema = _context.sent;
+            this.initialized = !!this.schema;
+            _context.next = 15;
             break;
-          case 5:
-            _context.prev = 5;
-            _context.t0 = _context["catch"](1);
+          case 11:
+            _context.prev = 11;
+            _context.t0 = _context["catch"](4);
+            console.log("获取schema失败!", {
+              id: this.formId,
+              mock: this.mock
+            });
             throw _context.t0;
-          case 8:
+          case 15:
             return _context.abrupt("return", this.initialized);
-          case 9:
+          case 16:
           case "end":
             return _context.stop();
         }
-      }, _callee, this, [[1, 5]]);
+      }, _callee, this, [[4, 11]]);
     }));
     function initialize() {
       return _initialize.apply(this, arguments);
@@ -94,65 +106,102 @@ export var RestFormApi = /*#__PURE__*/function (_RestApi) {
     }
     return getById;
   }();
-  _proto.create = /*#__PURE__*/function () {
-    var _create = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(data, options) {
+  _proto.save = /*#__PURE__*/function () {
+    var _save = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(data, options) {
+      var config;
       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:
+            config = {};
+            this.handleRequestConfig(config);
+            return _context4.abrupt("return", _RestApi.prototype.save.call(this, data, options));
+          case 5:
           case "end":
             return _context4.stop();
         }
       }, _callee4, this);
     }));
-    function create(_x6, _x7) {
-      return _create.apply(this, arguments);
+    function save(_x6, _x7) {
+      return _save.apply(this, arguments);
     }
-    return create;
+    return save;
   }();
-  _proto.update = /*#__PURE__*/function () {
-    var _update = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(id, data, options) {
+  _proto.create = /*#__PURE__*/function () {
+    var _create = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(data, options) {
+      var config;
       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:
+            config = {};
+            this.handleRequestConfig(config);
+            return _context5.abrupt("return", _RestApi.prototype.create.call(this, data, options));
+          case 5:
           case "end":
             return _context5.stop();
         }
       }, _callee5, this);
     }));
-    function update(_x8, _x9, _x10) {
-      return _update.apply(this, arguments);
+    function create(_x8, _x9) {
+      return _create.apply(this, arguments);
     }
-    return update;
+    return create;
   }();
-  _proto.deleteById = /*#__PURE__*/function () {
-    var _deleteById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(id, options) {
+  _proto.update = /*#__PURE__*/function () {
+    var _update = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(id, data, options) {
+      var config;
       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:
+            config = {};
+            this.handleRequestConfig(config);
+            return _context6.abrupt("return", _RestApi.prototype.update.call(this, id, data, options));
+          case 5:
           case "end":
             return _context6.stop();
         }
       }, _callee6, this);
     }));
-    function deleteById(_x11, _x12) {
+    function update(_x10, _x11, _x12) {
+      return _update.apply(this, arguments);
+    }
+    return update;
+  }();
+  _proto.deleteById = /*#__PURE__*/function () {
+    var _deleteById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(id, options) {
+      var config;
+      return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return this.initialize();
+          case 2:
+            config = {};
+            this.handleRequestConfig(config);
+            return _context7.abrupt("return", _RestApi.prototype.deleteById.call(this, id, options));
+          case 5:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7, this);
+    }));
+    function deleteById(_x13, _x14) {
       return _deleteById.apply(this, arguments);
     }
     return deleteById;
   }();
+  _proto.handleRequestConfig = function handleRequestConfig(config) {
+    config.params = config.params || {};
+    config.params.formId = this.formId;
+    config.params.mock = this.mock;
+  };
   return RestFormApi;
 }(RestApi);

package/es/utils/form/form.instance.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/form/form.instance.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/index.d.ts

@@ -1,8 +1,10 @@
+import * as cache from "./cache";
 import * as common from "./common";
 import * as api from "./api";
 import * as designer from "./designer";
 declare const _default: {
     api: typeof api;
+    cache: typeof cache;
     designer: typeof designer;
     common: typeof common;
 };

package/es/utils/index.js

@@ -1,8 +1,10 @@
+import * as cache from "./cache";
 import * as common from "./common";
 import * as api from "./api";
 import * as designer from "./designer";
 export default {
   api: api,
+  cache: cache,
   designer: designer,
   common: common
 };

package/lib/components/schema-render/components/schema-render-base.js

@@ -49,7 +49,7 @@ var SchemaRenderBase = exports.SchemaRenderBase = /*#__PURE__*/function (_Compon
             return _context.abrupt("return");
           case 6:
             _context.next = 8;
-            return _utils["default"].common.schemaCache.get(schemaId);
+            return _utils["default"].request.getSchema(schemaId);
           case 8:
             schema = _context.sent;
             _this.setState({

package/lib/index.d.ts

@@ -1,7 +1,6 @@
 import utils from "./utils";
-export { RestApi } from "./utils/common/RestApi";
-export { RestFormApi } from "./utils/common/RestFormApi";
-export { ClientCache } from "./utils/common/ClientCache";
+export { RestApi } from "./utils/api/RestApi";
+export { RestFormApi } from "./utils/form/form.api";
 export { Layout } from "./components/layout";
 export { SchemaRender } from "./components/schema-render";
 export { ReactRender } from "./components/react-render";

package/lib/index.js

@@ -2,15 +2,13 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 exports.__esModule = true;
-exports.SchemaRender = exports.RestFormApi = exports.RestApi = exports.ReactRender = exports.Layout = exports.ClientCache = void 0;
+exports.SchemaRender = exports.RestFormApi = exports.RestApi = exports.ReactRender = exports.Layout = void 0;
 var _utils = _interopRequireDefault(require("./utils"));
 exports.utils = _utils["default"];
-var _RestApi = require("./utils/common/RestApi");
+var _RestApi = require("./utils/api/RestApi");
 exports.RestApi = _RestApi.RestApi;
-var _RestFormApi = require("./utils/common/RestFormApi");
-exports.RestFormApi = _RestFormApi.RestFormApi;
-var _ClientCache = require("./utils/common/ClientCache");
-exports.ClientCache = _ClientCache.ClientCache;
+var _form = require("./utils/form/form.api");
+exports.RestFormApi = _form.RestFormApi;
 var _layout = require("./components/layout");
 exports.Layout = _layout.Layout;
 var _schemaRender = require("./components/schema-render");

package/lib/utils/{common → api}/RestApi.d.ts

@@ -1,4 +1,4 @@
-import { AxiosInstance } from "axios";
+import { AxiosInstance, AxiosRequestConfig } from "axios";
 export interface RestApiOptions {
     /**
      * 超时时间
@@ -9,31 +9,33 @@ export interface RestApiOptions {
      */
     title?: string;
 }
-export declare class RestApi<DataType> {
+export declare abstract class RestApi<DataType> {
     uri: string;
     title: string;
     request: AxiosInstance;
-    constructor(uri: string, options?: RestApiOptions);
+    protected constructor(uri: string, options?: RestApiOptions);
+    abstract handleRequestConfig(config: AxiosRequestConfig): void;
     search(params?: Record<string, any>, page?: number, pageSize?: number): Promise<ManyResult<DataType>>;
     /**
      * 通过id获取
      * @param id
      * @param options
      */
-    getById(id: string, options?: BaseRequestOptions<DataType>): Promise<DataType & BaseType>;
+    getById(id: string, options?: BaseRequestOptions<DataType>): Promise<OneResult<DataType>>;
+    save(data: DataType, options?: BaseRequestOptions<DataType>): Promise<OneResult<DataType>>;
     /**
      * 创建
      */
-    create(data: DataType, options?: BaseRequestOptions<DataType>): Promise<DataType & BaseType>;
+    create(data: DataType, options?: BaseRequestOptions<DataType>): Promise<OneResult<DataType>>;
     /**
      * 更新
      */
-    update(id: string, data: DataType, options?: BaseRequestOptions<DataType>): Promise<DataType & BaseType>;
+    update(id: string, data: DataType, options?: BaseRequestOptions<DataType>): Promise<OneResult<DataType>>;
     /**
      * 通过id删除
      */
-    deleteById(id: string, options?: BaseRequestOptions<DataType>): Promise<boolean>;
-    showError(type?: string, msg?: string): Promise<void>;
+    deleteById(id: string, options?: BaseRequestOptions<DataType>): Promise<OneResult<DataType>>;
+    private showError;
 }
 export interface BaseType {
     /**