@byteluck-fe/model-driven-core 1.3.0-beta.27 → 1.5.0-beta.1

package/dist/esm/common/BaseControl/designer.js

@@ -0,0 +1,409 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i1 = 0, arr2 = new Array(len); i1 < len; i1++)arr2[i1] = arr[i1];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i1 = 0; i1 < props.length; i1++){
+        var descriptor = props[i1];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i1 = 1; i1 < arguments.length; i1++){
+        var source = arguments[i1] != null ? arguments[i1] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _toArray(arr) {
+    return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import regeneratorRuntime from "regenerator-runtime";
+import Property from "./property";
+import { genNonDuplicateId, JSONCopy, referenceError, updateValueFromKeys } from "@byteluck-fe/model-driven-shared";
+import { createValidator } from "../Validator";
+import { controlHooksEmitter } from "../controlHooksEmitter";
+var Control = /*#__PURE__*/ function _target() {
+    "use strict";
+    function Control(props) {
+        var _this = this;
+        _classCallCheck(this, Control);
+        this.setting = [];
+        this.eventKeys = [];
+        this.customEvents = [];
+        this.parent = null;
+        this.updateSetting = updateSetting;
+        this.removeSetting = removeSetting;
+        this._callControlHooks("preInstance", props);
+        var ref = _instanceof(this, Control) ? this.constructor : void 0, controlName = ref.controlName, controlIcon = ref.controlIcon, controlType = ref.controlType, controlFieldType = ref.controlFieldType, controlEventKeys = ref.controlEventKeys, controlCustomEvents = ref.controlCustomEvents, name = ref.name, setting = ref.setting;
+        if (!(controlName && controlIcon && controlType)) {
+            referenceError("The ".concat(name, " controlName,controlIcon,controlType is not define"));
+        }
+        var ref1;
+        this.id = (ref1 = props === null || props === void 0 ? void 0 : props.id) !== null && ref1 !== void 0 ? ref1 : genNonDuplicateId(10);
+        this.name = controlName;
+        this.icon = controlIcon;
+        var ref2;
+        this.type = (ref2 = props === null || props === void 0 ? void 0 : props.type) !== null && ref2 !== void 0 ? ref2 : controlType;
+        this.props = new Property(props === null || props === void 0 ? void 0 : props.props, (_instanceof(this, Control) ? this.constructor : void 0).controlName);
+        var ref3;
+        this.controlType = (ref3 = props === null || props === void 0 ? void 0 : props.controlType) !== null && ref3 !== void 0 ? ref3 : "base";
+        this.setting = JSONCopy(setting);
+        var ref4;
+        this.fieldType = (ref4 = props === null || props === void 0 ? void 0 : props.fieldType) !== null && ref4 !== void 0 ? ref4 : controlFieldType;
+        this.eventKeys = JSONCopy(controlEventKeys);
+        this.customEvents = JSONCopy(controlCustomEvents);
+        Promise.resolve().then(function() {
+            _this._callControlHooks("postInstance", props);
+        });
+    }
+    var _proto = Control.prototype;
+    _proto._callControlHooks = function _callControlHooks() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        var _controlHooksEmitter;
+        var _args = _toArray(args), key = _args[0], arg = _args.slice(1);
+        return (_controlHooksEmitter = controlHooksEmitter).emit.apply(_controlHooksEmitter, [
+            key,
+            this
+        ].concat(_toConsumableArray(arg)));
+    };
+    _proto.preUpdate = function preUpdate(key, value) {
+        // 在修改props之前
+        this._callControlHooks("preUpdateProps", key, value);
+    };
+    _proto.postUpdate = function postUpdate(key, value) {
+        // 在修改props之后
+        this._callControlHooks("postUpdateProps", key, value);
+    };
+    // 修改实例上的props，key可以是caption,caption.zh...
+    _proto.updateProps = function updateProps(key, value) {
+        this.preUpdate(key, value);
+        updateValueFromKeys(this.props, key, value);
+        this.postUpdate(key, value);
+    };
+    _proto.preValidate = function preValidate() {
+        var _this = this;
+        return _asyncToGenerator(/*#__PURE__*/ regeneratorRuntime.mark(function _callee() {
+            var rules, results, result;
+            return regeneratorRuntime.wrap(function _callee$(_ctx) {
+                while(1)switch(_ctx.prev = _ctx.next){
+                    case 0:
+                        rules = _objectSpread({}, _this.rules);
+                        _ctx.next = 3;
+                        return _this._callControlHooks("preValidate", rules);
+                    case 3:
+                        results = _ctx.sent;
+                        result = results[results.length - 1];
+                        return _ctx.abrupt("return", result === false ? undefined : result);
+                    case 6:
+                    case "end":
+                        return _ctx.stop();
+                }
+            }, _callee);
+        }))();
+    };
+    // property校验
+    _proto.validate = function validate(messages, ignore) {
+        var _this = this;
+        return _asyncToGenerator(/*#__PURE__*/ regeneratorRuntime.mark(function _callee() {
+            var result, rules, validator;
+            return regeneratorRuntime.wrap(function _callee$(_ctx) {
+                while(1)switch(_ctx.prev = _ctx.next){
+                    case 0:
+                        _ctx.next = 2;
+                        return _this.preValidate();
+                    case 2:
+                        result = _ctx.sent;
+                        rules = result !== undefined ? result : _objectSpread({}, _this.rules);
+                        if (Array.isArray(ignore)) {
+                            ignore.forEach(function(key) {
+                                if (rules.hasOwnProperty(key)) {
+                                    delete rules[key];
+                                }
+                            });
+                        }
+                        validator = createValidator(rules, messages);
+                        _ctx.prev = 6;
+                        _ctx.next = 9;
+                        return validator.validate(_this.props);
+                    case 9:
+                        return _ctx.abrupt("return", true);
+                    case 12:
+                        _ctx.prev = 12;
+                        _ctx.t0 = _ctx["catch"](6);
+                        if (!_ctx.t0.control) {
+                            _ctx.t0.control = _this;
+                        }
+                        throw _ctx.t0;
+                    case 16:
+                    case "end":
+                        return _ctx.stop();
+                }
+            }, _callee, null, [
+                [
+                    6,
+                    12
+                ]
+            ]);
+        }))();
+    };
+    _proto.toDataBindModel = function toDataBindModel() {
+        var parentId = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+        var fieldType = this.fieldType;
+        var controlId = this.id;
+        var type = this.type;
+        var _props = this.props, dataBind = _props.dataBind, datasourceBind = _props.datasourceBind, optionConfig = _props.optionConfig, caption = _props.caption, required = _props.required, maxLength = _props.maxLength, options = _props.options, encrypted = _props.encrypted, encryptedMode = _props.encryptedMode;
+        if (!fieldType && !dataBind && !datasourceBind) return;
+        var dataBindModelType = {
+            parentId: parentId,
+            fieldType: fieldType,
+            controlId: controlId,
+            caption: caption,
+            type: type,
+            props: {}
+        };
+        if (dataBind) {
+            dataBindModelType.dataBind = dataBind;
+        }
+        switch(optionConfig){
+            case "datasource":
+            case undefined:
+                if (datasourceBind) {
+                    dataBindModelType.datasourceBind = datasourceBind;
+                }
+                break;
+            case "custom":
+                dataBindModelType.props.options = options;
+                break;
+        }
+        if (required !== undefined) {
+            dataBindModelType.required = required;
+        }
+        if (maxLength !== undefined) {
+            dataBindModelType.maxLength = maxLength;
+        }
+        if (encrypted !== undefined) {
+            dataBindModelType.encrypted = encrypted;
+        }
+        if (encryptedMode !== undefined) {
+            dataBindModelType.encryptedMode = encryptedMode;
+        }
+        return dataBindModelType;
+    };
+    _proto.preToSchema = function preToSchema() {
+        // 在处理Schema之前，预留的钩子函数，允许在toSchema之前处理一些数据
+        this._callControlHooks("preToSchema", this);
+    };
+    _proto.toSchema = function toSchema() {
+        this.preToSchema();
+        return {
+            id: this.id,
+            type: this.type,
+            props: JSONCopy(this.props),
+            fieldType: this.fieldType,
+            controlType: this.controlType
+        };
+    };
+    Control.updateBasicControl = function updateBasicControl(key, setting) {
+        if (key !== "setting") return;
+        if (setting.add) {
+            var _setting;
+            (_setting = this.setting).push.apply(_setting, _toConsumableArray(setting.add));
+        }
+        if (setting.remove) {
+            this.removeSettingItem(setting.remove);
+        }
+        if (setting.update) {
+        // this.updateSettingItem(setting.update, false)
+        }
+    };
+    _createClass(Control, [
+        {
+            key: "rules",
+            get: function get() {
+                var Rules = this.props.constructor.Rules;
+                if (Rules) {
+                    return new Rules(this.props);
+                }
+                return {};
+            }
+        }
+    ]);
+    return Control;
+}();
+Control.controlName = "控件";
+Control.controlIcon = "icon";
+Control.controlType = "control";
+// 控件可以触发的事件key
+Control.controlEventKeys = [];
+Control.controlCustomEvents = [];
+// setting应该是全量的设置项，外部控制，在初始化的时候会deepCopy一份
+Control.setting = [];
+Control.__is_control__ = true;
+// 删除指定的settingItem
+Control.removeSettingItem = removeSetting;
+// 修改指定的settingItem的visible
+Control.updateSettingItem = updateSetting;
+export default Control;
+export { Control as DesignerControl };
+/**
+ * @function 删除控件或者实例上的setting的方法
+ * @description 其中的this可能是DesignerControl的类，也可以是实例
+ * @param keys 需要删除的key或key组成的数组
+ * */ function removeSetting(keys) {
+    var _this = this;
+    var deleteKeys = Array.isArray(keys) ? keys : [
+        keys
+    ];
+    deleteKeys.forEach(function(deleteKey) {
+        // 是否存在子项
+        var isHasItem = typeof deleteKey !== "string";
+        // @ts-ignore
+        var settingIndex = _this.setting.findIndex(function(option) {
+            return option.key === (isHasItem ? deleteKey.key : deleteKey);
+        });
+        // 移除对应选项
+        if (settingIndex !== -1) {
+            var ref, ref1;
+            isHasItem ? _this.setting[settingIndex].showItems = (ref = _this.setting[settingIndex].showItems) === null || ref === void 0 ? void 0 : ref.filter(function(item) {
+                return !deleteKey.hideItems.includes(item);
+            }) : _this.setting.splice(settingIndex, 1);
+            // 子项长度为0，自动移除当前设置项
+            isHasItem && // @ts-ignore
+            !((ref1 = _this.setting[settingIndex].showItems) === null || ref1 === void 0 ? void 0 : ref1.length) && // @ts-ignore
+            _this.setting.splice(settingIndex, 1);
+        }
+    });
+}
+/**
+ * @function 修改控件或者实例上的setting的方法
+ * @description 其中的this可能是DesignerControl的类，也可以是实例
+ * @param settingKey 需要修改的key或者key组成的数组
+ * @param value 修改之后的visible值
+ * @param value.showItems 需要添加或替换的showItems
+ * @param value.type 默认是replace替换，可以更改为push新增
+ * */ function updateSetting(settingKey, value) {
+    var _this = this;
+    var keys = typeof settingKey === "string" ? [
+        settingKey
+    ] : settingKey;
+    keys.forEach(function(key) {
+        // @ts-ignore
+        var settingItem = _this.setting.find(function(item) {
+            return item.key === key;
+        });
+        if (settingItem) {
+            if (typeof value === "boolean") {
+                settingItem.visible = value;
+            } else if (typeof value === "object") {
+                var _type;
+                var type = (_type = value.type) !== null && _type !== void 0 ? _type : "replace";
+                if (type === "replace") {
+                    settingItem.showItems = value.showItems;
+                } else {
+                    var _showItems;
+                    (_showItems = settingItem.showItems).push.apply(_showItems, _toConsumableArray(value.showItems));
+                }
+            }
+        }
+    });
+}

package/dist/esm/common/BaseControl/index.js

@@ -0,0 +1,12 @@
+import Designer from "./designer";
+import Runtime from "./runtime";
+import Property from "./property";
+export default {
+    Designer: Designer,
+    Runtime: Runtime,
+    Property: Property
+};
+export * from "./designer";
+export * from "./runtime";
+export * from "./property";
+export * from "./types";

package/dist/esm/common/BaseControl/property.js

@@ -0,0 +1,160 @@
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return _wrapNativeSuper(Class);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+import { BaseStyle } from "../../framework";
+var PropertyRules = function PropertyRules(props) {
+    "use strict";
+    _classCallCheck(this, PropertyRules);
+    this.isHide = {
+        type: "boolean"
+    };
+};
+var PropertyRuntimeRules = /*#__PURE__*/ function(Array1) {
+    "use strict";
+    _inherits(PropertyRuntimeRules, Array1);
+    var _super = _createSuper(PropertyRuntimeRules);
+    function PropertyRuntimeRules(props) {
+        _classCallCheck(this, PropertyRuntimeRules);
+        return _super.call(this);
+    }
+    return PropertyRuntimeRules;
+}(_wrapNativeSuper(Array));
+var Property = function Property(props) {
+    "use strict";
+    var caption = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+    _classCallCheck(this, Property);
+    var ref;
+    this.isHide = (ref = props === null || props === void 0 ? void 0 : props.isHide) !== null && ref !== void 0 ? ref : false;
+    this.style = new BaseStyle(props === null || props === void 0 ? void 0 : props.style);
+    var ref1;
+    this.caption = (ref1 = props === null || props === void 0 ? void 0 : props.caption) !== null && ref1 !== void 0 ? ref1 : caption;
+};
+Property.Rules = PropertyRules;
+Property.RuntimeRules = PropertyRuntimeRules;
+export default Property;
+export { Property, PropertyRules, PropertyRuntimeRules };

package/dist/esm/common/BaseControl/runtime.js

@@ -0,0 +1,72 @@
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+import Property from "./property";
+import { genNonDuplicateId, referenceError } from "@byteluck-fe/model-driven-shared";
+import { PAGE_STATUS } from "../../framework";
+var Control = /*#__PURE__*/ function _target() {
+    "use strict";
+    function Control(props) {
+        _classCallCheck(this, Control);
+        this.customEvents = [];
+        this.parent = null;
+        var ref = _instanceof(this, Control) ? this.constructor : void 0, controlType = ref.controlType, controlFieldType = ref.controlFieldType, name = ref.name, controlCustomEvents = ref.controlCustomEvents;
+        if (!controlType) {
+            referenceError("The ".concat(name, " controlType is not define"));
+        }
+        var ref1;
+        this.id = (ref1 = props === null || props === void 0 ? void 0 : props.id) !== null && ref1 !== void 0 ? ref1 : genNonDuplicateId(10);
+        var ref2;
+        this.type = (ref2 = props === null || props === void 0 ? void 0 : props.type) !== null && ref2 !== void 0 ? ref2 : controlType;
+        this.props = new Property(props === null || props === void 0 ? void 0 : props.props);
+        this.customEvents = controlCustomEvents;
+        var ref3;
+        this.controlType = (ref3 = props === null || props === void 0 ? void 0 : props.controlType) !== null && ref3 !== void 0 ? ref3 : "base";
+        var ref4;
+        this.fieldType = (ref4 = props === null || props === void 0 ? void 0 : props.fieldType) !== null && ref4 !== void 0 ? ref4 : controlFieldType;
+        var ref5;
+        this.pageStatus = (ref5 = props === null || props === void 0 ? void 0 : props.pageStatus) !== null && ref5 !== void 0 ? ref5 : PAGE_STATUS.UNKNOWN;
+    }
+    _createClass(Control, [
+        {
+            key: "rules",
+            get: function get() {
+                var Rules = this.props.constructor.RuntimeRules;
+                if (Rules) {
+                    var rules = new Rules(this.props);
+                    return Array.from(rules);
+                }
+                return [];
+            }
+        }
+    ]);
+    return Control;
+}();
+Control.controlType = "control";
+Control.__is_control__ = true;
+Control.controlCustomEvents = [];
+export default Control;
+export { Control as RuntimeControl };

package/dist/esm/common/BaseControl/types.js

@@ -0,0 +1 @@
+export { };