@zhubangyun/lowcode-core 5.3.131 → 5.3.181

package/es/utils/cache/index.js

@@ -0,0 +1,75 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { SingletonInstanceMap } from "../common/SingletonInstanceMap";
+import { request } from "../api";
+import { RestFormApi } from "../form/form.api";
+export var SchemaCache = /*#__PURE__*/function (_SingletonInstanceMap) {
+  function SchemaCache() {
+    return _SingletonInstanceMap.apply(this, arguments) || this;
+  }
+  _inheritsLoose(SchemaCache, _SingletonInstanceMap);
+  var _proto = SchemaCache.prototype;
+  _proto.createInstance = /*#__PURE__*/function () {
+    var _createInstance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(key) {
+      var mock, pageId;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            mock = key.endsWith("_mock");
+            pageId = key.replace("_mock", "");
+            _context.next = 4;
+            return request.get("pages/" + pageId + "/schema", {
+              params: {
+                mock: mock
+              }
+            });
+          case 4:
+            return _context.abrupt("return", _context.sent);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function createInstance(_x) {
+      return _createInstance.apply(this, arguments);
+    }
+    return createInstance;
+  }();
+  return SchemaCache;
+}(SingletonInstanceMap);
+export var schema = new SchemaCache();
+export var FormApiCache = /*#__PURE__*/function (_SingletonInstanceMap2) {
+  function FormApiCache() {
+    return _SingletonInstanceMap2.apply(this, arguments) || this;
+  }
+  _inheritsLoose(FormApiCache, _SingletonInstanceMap2);
+  var _proto2 = FormApiCache.prototype;
+  _proto2.createInstance = /*#__PURE__*/function () {
+    var _createInstance2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(key) {
+      var mock, formId, formApi;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            mock = key.endsWith("_mock");
+            formId = key.replace("_mock", "");
+            formApi = new RestFormApi(formId, mock);
+            _context2.next = 5;
+            return formApi.initialize();
+          case 5:
+            return _context2.abrupt("return", formApi);
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    function createInstance(_x2) {
+      return _createInstance2.apply(this, arguments);
+    }
+    return createInstance;
+  }();
+  return FormApiCache;
+}(SingletonInstanceMap);
+export var formApi = new FormApiCache();

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

@@ -0,0 +1,7 @@
+export declare abstract class SingletonInstanceMap<Value> {
+    private readonly valueMap;
+    private readonly lockMap;
+    getInstance(key: string): Promise<Value>;
+    clear(): void;
+    abstract createInstance(key: string): Promise<Value>;
+}

package/es/utils/common/SingletonInstanceMap.js

@@ -0,0 +1,73 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export var SingletonInstanceMap = /*#__PURE__*/function () {
+  function SingletonInstanceMap() {
+    this.valueMap = new Map();
+    this.lockMap = new Map();
+  }
+  var _proto = SingletonInstanceMap.prototype;
+  _proto.getInstance = /*#__PURE__*/function () {
+    var _getInstance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(key) {
+      var self, value;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            self = this;
+            if (!this.valueMap.has(key)) {
+              _context2.next = 5;
+              break;
+            }
+            return _context2.abrupt("return", Promise.resolve(this.valueMap.get(key)));
+          case 5:
+            if (!this.lockMap.get(key)) {
+              _context2.next = 9;
+              break;
+            }
+            return _context2.abrupt("return", new Promise(function (resolve, reject) {
+              setTimeout( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+                return _regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      resolve(self.getInstance(key));
+                    case 1:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              })), 1000);
+            }));
+          case 9:
+            _context2.prev = 9;
+            this.lockMap.set(key, true);
+            _context2.next = 13;
+            return this.createInstance(key);
+          case 13:
+            value = _context2.sent;
+            this.valueMap.set(key, value);
+            this.lockMap.set(key, false);
+            return _context2.abrupt("return", Promise.resolve(value));
+          case 19:
+            _context2.prev = 19;
+            _context2.t0 = _context2["catch"](9);
+            throw _context2.t0;
+          case 22:
+            _context2.prev = 22;
+            this.lockMap.set(key, false);
+            return _context2.finish(22);
+          case 25:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this, [[9, 19, 22, 25]]);
+    }));
+    function getInstance(_x) {
+      return _getInstance.apply(this, arguments);
+    }
+    return getInstance;
+  }();
+  _proto.clear = function clear() {
+    this.lockMap.clear();
+    this.valueMap.clear();
+  };
+  return SingletonInstanceMap;
+}();

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

@@ -1,4 +1,2 @@
-import { 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

@@ -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/react-render/index.d.ts

@@ -1,10 +1,7 @@
-import React, { PureComponent } from "react";
-export declare class ReactRender extends PureComponent<{
-    schema: any;
-    components?: any;
-    style?: React.CSSProperties;
-}> {
+import { PureComponent } from 'react';
+import { IRendererProps } from "@zhubangyun/lowcode-render-core/lib/types";
+export declare class ReactRender extends PureComponent<IRendererProps & {}> {
     key: string;
-    jsx: any;
-    render(): JSX.Element;
+    node: any;
+    render(): import("react").JSX.Element;
 }

package/lib/components/react-render/index.js

@@ -5,18 +5,10 @@ exports.__esModule = true;
 exports.ReactRender = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
-var _configProvider = _interopRequireDefault(require("antd/lib/config-provider"));
-var _lowcodeRenderCore = _interopRequireWildcard(require("@zhubangyun/lowcode-render-core"));
-var _react = _interopRequireWildcard(require("react"));
-var _utils = _interopRequireDefault(require("../../utils"));
+var _react = require("react");
 var _lowcodeDatasourceFetchHandler = require("@alilc/lowcode-datasource-fetch-handler");
-var _window$antd, _window$antd2;
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
-// @ts-ignore
-_lowcodeRenderCore.adapter.setConfigProvider(((_window$antd = window.antd) === null || _window$antd === void 0 ? void 0 : _window$antd.ConfigProvider) || _configProvider["default"]);
-// @ts-ignore
-var LocalConfig = ((_window$antd2 = window.antd) === null || _window$antd2 === void 0 ? void 0 : _window$antd2.ConfigProvider) || _configProvider["default"];
+var _reactRenderFactory = _interopRequireDefault(require("./react-render-factory"));
+var _utils = _interopRequireDefault(require("../../utils"));
 var ReactRender = exports.ReactRender = /*#__PURE__*/function (_PureComponent) {
   function ReactRender() {
     var _this;
@@ -25,25 +17,24 @@ var ReactRender = exports.ReactRender = /*#__PURE__*/function (_PureComponent) {
     }
     _this = _PureComponent.call.apply(_PureComponent, [this].concat(args)) || this;
     _this.key = Date.now().toString(36);
-    _this.jsx = void 0;
+    _this.node = void 0;
     return _this;
   }
   (0, _inheritsLoose2["default"])(ReactRender, _PureComponent);
   var _proto = ReactRender.prototype;
   _proto.render = function render() {
     var _this2 = this;
-    var key = this.key;
+    var components = this.props.components;
     // @ts-ignore
-    var components = this.props.components || window.components || {};
-    return /*#__PURE__*/_react["default"].createElement(_lowcodeRenderCore["default"], (0, _extends2["default"])({}, this.props, {
-      key: key,
-      ref: function ref(page) {
-        _this2.jsx = page === null || page === void 0 ? void 0 : page.__ref;
+    return /*#__PURE__*/React.createElement(_reactRenderFactory["default"], (0, _extends2["default"])({
+      key: this.key
+    }, this.props, {
+      ref: function ref(node) {
+        console.log(node);
+        _this2.node = node === null || node === void 0 ? void 0 : node.__ref;
       },
-      schema: this.props.schema,
       thisRequiredInJSE: true,
-      className: "schema-render",
-      components: components,
+      components: components || window.components || {},
       appHelper: {
         utils: _utils["default"],
         requestHandlersMap: {

package/lib/components/react-render/react-render-factory.d.ts

@@ -0,0 +1,3 @@
+import { types } from '@zhubangyun/lowcode-render-core';
+declare const _default: types.IRenderComponent;
+export default _default;