@cicctencent/low-code-simulate-base 0.0.0-stage → 1.1.9-beta.5

package/dist/domain/ComponentManager.d.ts

@@ -0,0 +1,78 @@
+import { Component, ComponentItem } from '@jt/low-code-core';
+/**
+ * @public
+ */
+export default class ComponentManager {
+    private static instance;
+    /**全局最大Id，从0开始 */
+    private maxId;
+    /**组件最大ID映射 ，从0开始*/
+    private componentMaxIdMap;
+    /**组件个数统计，从1开始 */
+    private componentCountMap;
+    private static componentSchemaMap;
+    private constructor();
+    /**
+     *  @public
+     *  提供一个公共的静态方法来获取单例实例
+     * @param componentConfigs - 组件配置
+     * @returns
+     */
+    static getInstance(componentConfigs?: Component[]): ComponentManager;
+    /**
+     *  @public
+     * @param name - 组件名
+     * @returns
+     */
+    get(name: string): Component;
+    /**
+     * @public
+     * 初始化
+     * @param components - 组件列表
+     */
+    initComponens(components: ComponentItem[]): void;
+    /**
+     * @public
+     * @returns
+     */
+    getImxId(): number;
+    /**
+     *  @public
+     * @param name - 组件名
+     * @returns
+     */
+    private createId;
+    /**
+     *  @public
+     * 插入、点击或复制时创建新的组件数据
+     * @param item - 组件信息
+     * @returns
+     */
+    buildItemData(item: ComponentItem | Component): ComponentItem;
+    /**
+     * @public
+     * 复制组件数据
+     * @param component - 组件
+     * @returns
+     */
+    copy(component: ComponentItem): ComponentItem;
+    /**
+     * @public
+     *  填充数据
+     */
+    private fillFieldData;
+    /**
+     * @public
+     * 删除
+     * @param name - 组件名
+     */
+    delete(name: string): void;
+    /**
+     *  @public
+     * 其他方法，例如更新maxId和映射
+     * @param components - 组件列表
+     * @param componentIds - 组件id列表
+     * @returns
+     */
+    private updateComponentMaps;
+}

package/dist/domain/ComponentManager.js

@@ -0,0 +1,293 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { ComponentType } from '@jt/low-code-core';
+import { getSchemaObjectAttribute } from '../utils';
+import { cloneDeep, merge, get, set } from '@jt/ark-util';
+import { transformSchemaToForm } from '../utils/transform';
+/**
+ * @public
+ */
+var ComponentManager = /** @class */ (function () {
+    // 私有构造函数确保外部代码不能使用new操作符创建新的实例
+    function ComponentManager() {
+        /**全局最大Id，从0开始 */
+        this.maxId = 0;
+        /**组件最大ID映射 ，从0开始*/
+        this.componentMaxIdMap = {};
+        /**组件个数统计，从1开始 */
+        this.componentCountMap = {};
+    }
+    /**
+     *  @public
+     *  提供一个公共的静态方法来获取单例实例
+     * @param componentConfigs - 组件配置
+     * @returns
+     */
+    ComponentManager.getInstance = function (componentConfigs) {
+        var e_1, _a;
+        if (!ComponentManager.instance) {
+            ComponentManager.instance = new ComponentManager();
+        }
+        if (componentConfigs) {
+            try {
+                for (var componentConfigs_1 = __values(componentConfigs), componentConfigs_1_1 = componentConfigs_1.next(); !componentConfigs_1_1.done; componentConfigs_1_1 = componentConfigs_1.next()) {
+                    var item = componentConfigs_1_1.value;
+                    ComponentManager.componentSchemaMap[item.name] = item;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (componentConfigs_1_1 && !componentConfigs_1_1.done && (_a = componentConfigs_1.return)) _a.call(componentConfigs_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        return ComponentManager.instance;
+    };
+    /**
+     *  @public
+     * @param name - 组件名
+     * @returns
+     */
+    ComponentManager.prototype.get = function (name) {
+        return ComponentManager.componentSchemaMap[name];
+    };
+    /**
+     * @public
+     * 初始化
+     * @param components - 组件列表
+     */
+    ComponentManager.prototype.initComponens = function (components) {
+        this.updateComponentMaps(components);
+        this.maxId = Math.max.apply(Math, __spreadArray([0], __read(this.updateComponentMaps(components)), false));
+    };
+    /**
+     * @public
+     * @returns
+     */
+    ComponentManager.prototype.getImxId = function () {
+        return this.maxId;
+    };
+    // 创建id
+    /**
+     *  @public
+     * @param name - 组件名
+     * @returns
+     */
+    ComponentManager.prototype.createId = function (name) {
+        ++this.maxId;
+        this.componentMaxIdMap[name] = (this.componentMaxIdMap[name] || 0) + 1;
+        this.componentCountMap[name] = (this.componentCountMap[name] || 0) + 1;
+        // 先加后用
+        return {
+            componentId: this.maxId,
+            nameId: this.componentMaxIdMap[name],
+        };
+    };
+    /**
+     *  @public
+     * 插入、点击或复制时创建新的组件数据
+     * @param item - 组件信息
+     * @returns
+     */
+    ComponentManager.prototype.buildItemData = function (item) {
+        var _a;
+        if ('componentId' in item) {
+            // 已经初始化过的直接返回
+            return item;
+        }
+        var schema = this.get(item.name);
+        var originTitle = schema.title;
+        var _b = this.createId(item.name), componentId = _b.componentId, nameId = _b.nameId;
+        var formData = 'formData' in item
+            ? this.fillFieldData(cloneDeep(item.formData), Object.assign({}, item, { componentId: componentId }))
+            : this.fillFieldData({}, Object.assign({}, item, { componentId: componentId }));
+        var itemData = {
+            title: originTitle + (nameId === 1 ? '' : nameId),
+            name: schema.name,
+            icon: schema.icon,
+            // picture: item.picture,
+            isNoLogin: (_a = schema.isNoLogin) !== null && _a !== void 0 ? _a : false,
+            // group: item.group,
+            // 这里去掉了config，渲染数据不需要包含config
+            type: schema.type,
+            componentId: componentId,
+            // 这里的对象都要cloneDeep，避免影响原数据
+            formData: formData,
+            // 是否为不可移动元素
+            immobile: schema.immobile,
+        };
+        if ('children' in item || item.type === ComponentType.Container) {
+            itemData.children =
+                'children' in item ? item.children : [];
+        }
+        return itemData;
+    };
+    /**
+     * @public
+     * 复制组件数据
+     * @param component - 组件
+     * @returns
+     */
+    ComponentManager.prototype.copy = function (component) {
+        var e_2, _a;
+        var _this = this;
+        var _b, _c, _d;
+        var formData = cloneDeep(component === null || component === void 0 ? void 0 : component.formData);
+        var copyClearPaths = (_b = this.get(component.name)) === null || _b === void 0 ? void 0 : _b.copyClearPaths;
+        if (Array.isArray(copyClearPaths)) {
+            try {
+                for (var copyClearPaths_1 = __values(copyClearPaths), copyClearPaths_1_1 = copyClearPaths_1.next(); !copyClearPaths_1_1.done; copyClearPaths_1_1 = copyClearPaths_1.next()) {
+                    var path = copyClearPaths_1_1.value;
+                    try {
+                        var propValue = get(formData, path);
+                        // 找不到说明未配置该数据 不必再清除
+                        if (propValue === undefined)
+                            continue;
+                        // 属性名
+                        var propName = (_c = path.match(/\.(\w+)$/)) === null || _c === void 0 ? void 0 : _c[1];
+                        var config = getSchemaObjectAttribute(this.get(component.name).config, propName);
+                        // 不同类型对应清空后的值
+                        var typeToDefault = {
+                            object: {},
+                            array: [],
+                            default: null,
+                        };
+                        // 默认值
+                        var defaultValue = config === null || config === void 0 ? void 0 : config.default;
+                        var value = (_d = defaultValue !== null && defaultValue !== void 0 ? defaultValue : typeToDefault[config.type]) !== null && _d !== void 0 ? _d : typeToDefault.default;
+                        set(formData, path, value);
+                    }
+                    catch (error) {
+                        console.error('clear path error', error);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (copyClearPaths_1_1 && !copyClearPaths_1_1.done && (_a = copyClearPaths_1.return)) _a.call(copyClearPaths_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        var newComponent = __assign(__assign({}, this.get(component.name)), { formData: formData });
+        if (component.children && component.children.length) {
+            newComponent.children = component.children.map(function (c) {
+                return _this.copy(c);
+            });
+        }
+        return this.buildItemData(newComponent);
+    };
+    /**
+     * @public
+     *  填充数据
+     */
+    ComponentManager.prototype.fillFieldData = function (data, componentConfig) {
+        var config = this.get(componentConfig.name).config || {};
+        return merge(transformSchemaToForm(config, componentConfig), data);
+    };
+    /**
+     * @public
+     * 删除
+     * @param name - 组件名
+     */
+    ComponentManager.prototype.delete = function (name) {
+        var count = (this.componentCountMap[name] =
+            (this.componentCountMap[name] || 0) - 1);
+        this.componentCountMap[name] = count;
+        if (count === 0) {
+            this.componentMaxIdMap[name] = 0;
+        }
+    };
+    /**
+     *  @public
+     * 其他方法，例如更新maxId和映射
+     * @param components - 组件列表
+     * @param componentIds - 组件id列表
+     * @returns
+     */
+    ComponentManager.prototype.updateComponentMaps = function (components, componentIds) {
+        var e_3, _a;
+        var _b, _c, _d, _e;
+        if (componentIds === void 0) { componentIds = []; }
+        try {
+            for (var components_1 = __values(components), components_1_1 = components_1.next(); !components_1_1.done; components_1_1 = components_1.next()) {
+                var component = components_1_1.value;
+                var maxNumber = (((_b = component.title) === null || _b === void 0 ? void 0 : _b.match(/\d+$/)) || [])[0] || '';
+                var currentMax = (_c = this.componentMaxIdMap[component.name]) !== null && _c !== void 0 ? _c : 1;
+                this.componentMaxIdMap[component.name] = Math.max(currentMax, parseInt(maxNumber, 10) || 0);
+                this.componentCountMap[component.name] =
+                    ((_d = this.componentCountMap[component.name]) !== null && _d !== void 0 ? _d : 0) + 1;
+                componentIds.push(component.componentId);
+                if ((_e = component.children) === null || _e === void 0 ? void 0 : _e.length) {
+                    this.updateComponentMaps(component.children, componentIds);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (components_1_1 && !components_1_1.done && (_a = components_1.return)) _a.call(components_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return componentIds;
+    };
+    // 这里的schema需要读取配置文件
+    ComponentManager.componentSchemaMap = {};
+    return ComponentManager;
+}());
+export default ComponentManager;
+// // 使用单例
+// const manager = ComponentManager.getInstance();
+// manager.initComponens(components);
+// console.log(manager.maxId);
+// console.log(manager.componentMaxIdMap);
+// console.log(manager.componentCountMap);

package/dist/domain/DataHistoryDomain.d.ts

@@ -0,0 +1,53 @@
+/**
+ * DataHistoryDomain
+ * @public
+ * @typeParam T - 类型参数
+ */
+export default class DataHistoryDomain<T> {
+    /**
+     * 项目历史数据
+     * @public
+     */
+    historyList: Array<T>;
+    /**
+     * 历史数据指针
+     * @public
+     */
+    historyIndex: number;
+    /**
+     * @public
+     */
+    get data(): T;
+    /**
+     * @public
+     * 添加历史记录
+     */
+    add(data: T): boolean;
+    /**
+     * @public
+     *  更新
+     */
+    update(data: T): void;
+    /**
+     *  @public
+     */
+    get canUndo(): boolean;
+    /**
+     *  @public
+     */
+    get canRedo(): boolean;
+    /**
+     *  @public
+     * @returns
+     */
+    undo(): false | T;
+    /**
+     * @public
+     * @returns
+     */
+    redo(): false | T;
+    /**
+     *  @public
+     */
+    reset(): void;
+}

package/dist/domain/DataHistoryDomain.js

@@ -0,0 +1,110 @@
+/**数据历史管理 */
+import { cloneDeep, isEqual } from '@jt/ark-util';
+/**
+ * DataHistoryDomain
+ * @public
+ * @typeParam T - 类型参数
+ */
+var DataHistoryDomain = /** @class */ (function () {
+    function DataHistoryDomain() {
+        /**
+         * 项目历史数据
+         * @public
+         */
+        this.historyList = [];
+        /**
+         * 历史数据指针
+         * @public
+         */
+        this.historyIndex = -1;
+    }
+    Object.defineProperty(DataHistoryDomain.prototype, "data", {
+        /**
+         * @public
+         */
+        get: function () {
+            return this.historyList[this.historyIndex];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @public
+     * 添加历史记录
+     */
+    DataHistoryDomain.prototype.add = function (data) {
+        if (isEqual(this.data, data)) {
+            // 相等则直接返回
+            return false;
+        }
+        if (this.historyIndex < this.historyList.length - 1) {
+            // 撤销后再编辑，去掉后面的重做队列
+            this.historyList.splice(this.historyIndex + 1);
+        }
+        this.historyList = this.historyList.concat(cloneDeep(data));
+        // 虽然this.historyIndex++也可以，以下更稳
+        this.historyIndex = this.historyList.length - 1;
+        console.log('historyIndex----------', this.historyIndex, this.historyList);
+        return true;
+    };
+    /**
+     * @public
+     *  更新
+     */
+    DataHistoryDomain.prototype.update = function (data) {
+        if (this.historyIndex < 0) {
+            this.historyIndex = 0;
+        }
+        this.historyList[this.historyIndex] = cloneDeep(data);
+    };
+    Object.defineProperty(DataHistoryDomain.prototype, "canUndo", {
+        /**
+         *  @public
+         */
+        get: function () {
+            // 考虑到第1个数据为初始化数据。初始数据不可被撤销
+            return this.historyList.length > 1 && this.historyIndex > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DataHistoryDomain.prototype, "canRedo", {
+        /**
+         *  @public
+         */
+        get: function () {
+            return this.historyIndex < this.historyList.length - 1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     *  @public
+     * @returns
+     */
+    DataHistoryDomain.prototype.undo = function () {
+        if (this.canUndo) {
+            return this.historyList[--this.historyIndex];
+        }
+        return false;
+    };
+    /**
+     * @public
+     * @returns
+     */
+    DataHistoryDomain.prototype.redo = function () {
+        if (this.canRedo) {
+            return this.historyList[++this.historyIndex];
+        }
+        return false;
+    };
+    /**
+     *  @public
+     */
+    DataHistoryDomain.prototype.reset = function () {
+        this.historyList = [];
+        this.historyIndex = -1;
+    };
+    return DataHistoryDomain;
+}());
+export default DataHistoryDomain;