@gct-paas/design 0.1.5-test.2 → 0.1.6-dev.0

package/es/register/node/node.register.mjs

@@ -0,0 +1,141 @@
+import { DesignNodePrefix, DesignViewPrefix } from "../../constant/index.mjs";
+import "@gct-paas/core";
+//#region src/register/node/node.register.ts
+/**
+* 设计界面节点适配器注册
+*
+* @author zhanghanrui
+* @date 2024-07-06 11:07:57
+* @export
+* @class NodeRegister
+*/
+var NodeRegister = class {
+	/**
+	* 适配器缓存
+	*
+	* @author zhanghanrui
+	* @date 2024-07-06 11:07:15
+	* @protected
+	* @static
+	*/
+	static map = /* @__PURE__ */ new Map();
+	/**
+	* 实例缓存
+	*
+	* @author zhanghanrui
+	* @date 2024-07-06 12:07:33
+	* @protected
+	* @static
+	* @type {Map<string, INodeProvider>}
+	*/
+	static cache = /* @__PURE__ */ new Map();
+	/**
+	* 注册适配器
+	*
+	* @author zhanghanrui
+	* @date 2024-07-09 09:07:17
+	* @static
+	* @param {string} name
+	* @param {() => INodeProvider} provider
+	* @param {string} [prefix]
+	*/
+	static register(name, provider, prefix) {
+		const tag = prefix ? `${prefix}:${name}` : name;
+		this.map.set(tag, provider);
+	}
+	/**
+	* 获取适配器
+	*
+	* @author zhanghanrui
+	* @date 2024-07-09 09:07:49
+	* @static
+	* @param {string} name
+	* @param {string} [prefix]
+	* @return {*}  {(INodeProvider | null)}
+	*/
+	static get(name, prefix) {
+		const tag = prefix ? `${prefix}:${name}` : name;
+		if (this.cache.has(tag)) return this.cache.get(tag);
+		const provider = this.map.get(tag);
+		if (provider) {
+			const ins = provider();
+			this.cache.set(tag, ins);
+			return ins;
+		}
+		return null;
+	}
+	/**
+	* 注册自定义首页插件
+	*
+	* @author zhanghanrui
+	* @date 2024-07-09 09:07:44
+	* @static
+	* @param {string} name
+	* @param {() => INodeProvider} provider
+	*/
+	static registerCustomHome(name, provider) {
+		this.register(name, provider, DesignViewPrefix.CUSTOM_HOME);
+	}
+	/**
+	* 注册自定义导航页面插件
+	*
+	* @author zhanghanrui
+	* @date 2024-08-19 17:08:06
+	* @static
+	* @param {string} name
+	* @param {() => INodeProvider} provider
+	*/
+	static registerCustomExpView(name, provider) {
+		this.register(name, provider, DesignViewPrefix.CUSTOM_EXP_VIEW);
+	}
+	/**
+	* 注册自定义导航菜单页面插件
+	*
+	* @author zhanghanrui
+	* @date 2024-08-24 10:08:51
+	* @static
+	* @param {string} name
+	* @param {() => INodeProvider} provider
+	*/
+	static registerCustomExpMenu(name, provider) {
+		this.register(name, provider, DesignViewPrefix.CUSTOM_EXP_MENU);
+	}
+	/**
+	* 注册设计编辑器节点
+	*
+	* @author chitanda
+	* @date 2025-07-07 16:07:58
+	* @static
+	* @param {FIELD_TYPE} fieldType
+	* @param {() => INodeProvider} provider
+	*/
+	static registerDesignEditorNode(fieldType, provider) {
+		this.register(fieldType, provider, DesignNodePrefix.DESIGN_EDITOR);
+	}
+	/**
+	* 根据字段类型获取设计编辑器节点
+	*
+	* @author chitanda
+	* @date 2025-07-07 16:07:06
+	* @static
+	* @param {FIELD_TYPE} fieldType
+	* @returns {*}  {(INodeProvider | null)}
+	*/
+	static getDesignEditorNode(fieldType) {
+		return this.get(fieldType, DesignNodePrefix.DESIGN_EDITOR);
+	}
+	/**
+	* 获取自定义首页插件
+	*
+	* @author zhanghanrui
+	* @date 2024-07-09 09:07:58
+	* @static
+	* @param {string} name
+	* @return {*}  {(INodeProvider | null)}
+	*/
+	static getCustomHome(name) {
+		return this.get(name, DesignViewPrefix.CUSTOM_HOME);
+	}
+};
+//#endregion
+export { NodeRegister };

package/es/store/index.d.ts

@@ -0,0 +1 @@
+export { useDesignViewStore, type IDesignViewStore, } from './view/design-view.store';

package/es/store/index.mjs

@@ -0,0 +1 @@
+import "./view/design-view.store.mjs";

package/es/store/view/design-view.store.d.ts

@@ -0,0 +1,12 @@
+import { IDesignViewState, IDesignViewActions } from '../../interface';
+/**
+ * 设计视图状态
+ */
+export declare const useDesignViewStore: () => import('pinia').Store<string, IDesignViewState, IObject, IDesignViewActions>;
+/**
+ * 设计视图 store 类型
+ *
+ * @export
+ * @typedef {ReturnType<typeof useDesignViewStore>}
+ */
+export type IDesignViewStore = ReturnType<typeof useDesignViewStore>;

package/es/store/view/design-view.store.mjs

@@ -0,0 +1,327 @@
+import { DesignNodeType, DesignViewPrefix, InsertNodeMode } from "../../constant/index.mjs";
+import { NodeRegister } from "../../register/node/node.register.mjs";
+import "../../register/index.mjs";
+import { cloneDeep, merge } from "lodash-es";
+import { LinkedList } from "@gct-paas/core";
+import { reactive } from "vue";
+import { defineStore } from "pinia";
+import { uuid } from "@jsplumb/browser-ui";
+//#region src/store/view/design-view.store.ts
+/**
+* 设计视图状态
+*/
+var useDesignViewStore = () => {
+	const key = "design-view___" + uuid();
+	return defineStore(key, {
+		state() {
+			return {
+				uuid: key,
+				rootExpLabel: "页面",
+				prefix: DesignViewPrefix.CUSTOM_HOME,
+				isTriggerCache: true,
+				map: /* @__PURE__ */ new Map(),
+				pageNode: null,
+				selected: null,
+				hoverId: null,
+				isDragging: false,
+				isChange: false,
+				history: new LinkedList(),
+				count: 0,
+				tree: [],
+				expansions: /* @__PURE__ */ new Set(),
+				dropContainer: null
+			};
+		},
+		actions: {
+			getParentKey(id, parent = null, items = []) {
+				if (!id) return null;
+				if (items.length === 0) items = this.tree;
+				for (const _ of items) {
+					if (_.id === id) return parent ? parent.id : null;
+					if (_.children && _.children.length > 0) {
+						const result = this.getParentKey(id, _, _.children);
+						if (result) return result;
+					}
+				}
+				return null;
+			},
+			getTreeItem(tag, items = []) {
+				if (!tag) return null;
+				if (items.length === 0) items = this.tree;
+				for (const _ of items) {
+					if (_.id === tag) return _;
+					if (_.children && _.children.length > 0) {
+						const item = this.getTreeItem(tag, _.children);
+						if (item) return item;
+					}
+				}
+				return null;
+			},
+			getTreeItems(tag) {
+				let items = this.tree;
+				const treeItem = this.getTreeItem(tag);
+				if (treeItem) {
+					if (!treeItem.children) treeItem.children = [];
+					items = treeItem.children;
+				}
+				return items;
+			},
+			getChildren(node) {
+				if (node) {
+					const tag = typeof node === "string" ? node : node.id;
+					const item = this.getTreeItem(tag);
+					if (item && item.children) return item.children.map((_) => this.map.get(_.id));
+				} else return this.tree.map((_) => {
+					return this.map.get(_.id);
+				});
+				return [];
+			},
+			setDragging(bol) {
+				this.isDragging = bol;
+			},
+			activePage() {
+				this.selected = this.pageNode;
+			},
+			setActive(node) {
+				if (node == null) this.selected = null;
+				else if (typeof node === "string") if (this.map.has(node)) this.selected = this.map.get(node);
+				else console.warn(`节点[${node}]不存在`);
+				else this.selected = node;
+			},
+			getNode(tag) {
+				if (this.map.has(tag)) return this.map.get(tag);
+				return null;
+			},
+			updateNode(node) {
+				if (node && (node.type === DesignNodeType.PAGE || node.type === DesignNodeType.PAGE_LOWER)) {
+					this.pageNode = merge(this.pageNode, node);
+					this.pageNode.updateDate = Date.now();
+					this.isChange = true;
+					this.countAdd();
+					return;
+				}
+				if (!this.map.has(node.id)) {
+					node.updateDate = Date.now();
+					this.map.set(node.id, cloneDeep(node));
+				} else {
+					const data = this.map.get(node.id);
+					node.updateDate = Date.now();
+					this.map.set(node.id, merge(data, node));
+				}
+				this.isChange = true;
+			},
+			setNode(pKey, node, index) {
+				if (node && (node.type === DesignNodeType.PAGE || node.type === DesignNodeType.PAGE_LOWER)) {
+					this.pageNode = merge(this.pageNode, node);
+					this.pageNode.updateDate = Date.now();
+					this.isChange = true;
+					this.countAdd();
+					return node;
+				}
+				if (!pKey) pKey = this.getParentKey(node.id);
+				const nodes = this.getChildren(pKey);
+				let isNew = false;
+				if (!this.map.has(node.id)) {
+					node.updateDate = Date.now();
+					isNew = true;
+				} else {
+					const data = this.map.get(node.id);
+					node.updateDate = Date.now();
+					Object.assign(data, node);
+					node = data;
+				}
+				this.map.set(node.id, node);
+				if (nodes.length > 0 && index != null && index >= 0) this.insertNode(InsertNodeMode.BEFORE, nodes[index], node);
+				else if (isNew) {
+					this.setTreeItem(pKey, node.id, index);
+					this.cacheHistory();
+				}
+				this.isChange = true;
+				this.countAdd();
+				return node;
+			},
+			setTreeItem(pKey, id, i) {
+				const items = this.getTreeItems(pKey);
+				if (i != null) items.splice(i, 0, { id });
+				else items.push({ id });
+			},
+			moveTreeItem(oldPid, newPid, id, i) {
+				if (oldPid === newPid) {
+					const items = this.getTreeItems(newPid);
+					const oldIndex = items.findIndex((_) => _.id === id);
+					if (oldIndex !== -1) {
+						if (oldIndex === i) return;
+						const item = items[oldIndex];
+						if (i != null) if (i < oldIndex) {
+							items.splice(oldIndex, 1);
+							items.splice(i, 0, item);
+						} else {
+							items.splice(i, 0, item);
+							items.splice(oldIndex, 1);
+						}
+						else {
+							items.splice(oldIndex, 1);
+							items.push(item);
+						}
+					} else if (i != null) items.splice(i, 0, { id });
+					else items.push({ id });
+					return;
+				}
+				const oldItems = this.getTreeItems(oldPid);
+				const newItems = this.getTreeItems(newPid);
+				const oldIndex = oldItems.findIndex((_) => _.id === id);
+				if (oldIndex === -1) this.setTreeItem(newPid, id, i);
+				else {
+					const item = oldItems[oldIndex];
+					oldItems.splice(oldIndex, 1);
+					if (i != null) newItems.splice(i, 0, item);
+					else newItems.push(item);
+				}
+			},
+			deleteNode(arg) {
+				const tag = typeof arg === "string" ? arg : arg.id;
+				const data = this.getNode(tag);
+				if (data) {
+					const pKey = this.getParentKey(data.id);
+					const items = this.getTreeItems(pKey);
+					const i = items.findIndex((_) => _.id === data.id);
+					if (i !== -1) items.splice(i, 1);
+					this.map.delete(data.id);
+				}
+				this.isChange = true;
+				this.countAdd();
+				this.cacheHistory();
+				return data;
+			},
+			setNodes(nodes) {
+				nodes.forEach((node) => {
+					const p = NodeRegister.get(node.type, this.prefix);
+					if (p) {
+						const data = p.create(node);
+						if (data) this.map.set(data.id, data);
+					} else console.warn(`节点类型[${node.type}]，未注册适配器`);
+				});
+			},
+			insertNode(mode, node, data) {
+				const oldPKey = this.getParentKey(data.id);
+				const newPKey = this.getParentKey(node.id);
+				const id = data.id;
+				const index = this.getTreeItems(newPKey).findIndex((_) => _.id === node.id);
+				switch (mode) {
+					case InsertNodeMode.BEFORE:
+						this.moveTreeItem(oldPKey, newPKey, id, index);
+						break;
+					case InsertNodeMode.AFTER:
+						this.moveTreeItem(oldPKey, newPKey, id, index + 1);
+						break;
+					default:
+				}
+				this.map.set(data.id, data);
+				this.isChange = true;
+				this.countAdd();
+				this.cacheHistory();
+				return true;
+			},
+			setData: async function(data) {
+				if (data) {
+					if (!data.pageNode) {
+						const p = NodeRegister.get(DesignNodeType.PAGE, this.prefix) || NodeRegister.get(DesignNodeType.PAGE_LOWER, this.prefix);
+						if (p) {
+							this.pageNode = reactive(p.create());
+							this.pageNode.data = reactive(this.pageNode.data || {});
+						} else console.warn(`节点类型[${DesignNodeType.PAGE}]，未注册适配器`);
+					} else {
+						this.pageNode = reactive(data.pageNode);
+						this.pageNode.data = reactive(this.pageNode.data || {});
+					}
+					this.setNodes(data.nodes);
+					this.selected = this.pageNode;
+					if (data.nodes && data.nodes.length > 0 && (!data.tree || data.tree.length === 0)) {
+						const structureTree = (items) => {
+							const arr = [];
+							items.forEach((item) => {
+								const children = data.nodes.filter((_) => _.parentId === item.id).sort((a, b) => a.order - b.order);
+								if (children.length > 0) arr.push({
+									id: item.id,
+									children: structureTree(children)
+								});
+								else arr.push({ id: item.id });
+							});
+							return arr;
+						};
+						this.tree = structureTree(data.nodes.filter((_) => !_.parentId).sort((a, b) => a.order - b.order));
+					} else this.tree = data.tree || [];
+					this.cacheHistory();
+				}
+			},
+			getData() {
+				const deep = (items) => {
+					const arr = [];
+					if (items && items.length > 0) items.forEach((item) => {
+						arr.push(item.id);
+						if (item.children && item.children.length > 0) {
+							const childArr = deep(item.children);
+							arr.push(...childArr);
+						}
+					});
+					return arr;
+				};
+				const keys = deep(this.tree);
+				const nodes = cloneDeep(Array.from(this.map.values())).filter((_) => {
+					return keys.includes(_.id);
+				});
+				return {
+					type: this.prefix,
+					pageNode: cloneDeep(this.pageNode),
+					nodes,
+					tree: cloneDeep(this.tree)
+				};
+			},
+			getPaths(id) {
+				const arr = [];
+				let node = this.getNode(id);
+				if (node) {
+					arr.push(node);
+					let pKey = this.getParentKey(node.id);
+					while (pKey) {
+						node = this.getNode(pKey);
+						if (!node) break;
+						arr.unshift(node);
+						pKey = this.getParentKey(node.id);
+					}
+				}
+				return arr;
+			},
+			undo() {
+				this.history.prev();
+				if (this.history.active) {
+					this.tree = cloneDeep(this.history.active.data);
+					this.selected = this.pageNode;
+					this.isChange = true;
+				}
+			},
+			redo() {
+				this.history.next();
+				if (this.history.active) {
+					this.tree = cloneDeep(this.history.active.data);
+					this.selected = this.pageNode;
+					this.isChange = true;
+				}
+			},
+			cacheHistory() {
+				if (this.isTriggerCache) this.history.add(cloneDeep(this.tree));
+			},
+			countAdd() {
+				this.count += 1;
+			},
+			enableCache() {
+				this.isTriggerCache = true;
+			},
+			disableCache() {
+				this.isTriggerCache = false;
+			}
+		}
+	})();
+};
+//#endregion
+export { useDesignViewStore };

package/es/utils/can-drop/can-drop.d.ts

@@ -0,0 +1,12 @@
+import { IDesignNode, IDragDataItem } from '@gct-paas/schema';
+import { IDesignViewStore } from '../../store';
+/**
+ * 是否可以放置
+ *
+ * @export
+ * @param {IDesignNode} node 当前节点
+ * @param {IDesignViewStore} store 设计视图 store
+ * @param {IDragDataItem} item 拖拽数据
+ * @returns {*}  {boolean}
+ */
+export declare function isCanCrop(node: IDesignNode, store: IDesignViewStore, item: IDragDataItem): boolean;

package/es/utils/can-drop/can-drop.mjs

@@ -0,0 +1,48 @@
+import { NodeRegister } from "../../register/node/node.register.mjs";
+import "../../register/index.mjs";
+import { intersection, union } from "lodash-es";
+//#region src/utils/can-drop/can-drop.ts
+/**
+* 是否可以放置
+*
+* @export
+* @param {IDesignNode} node 当前节点
+* @param {IDesignViewStore} store 设计视图 store
+* @param {IDragDataItem} item 拖拽数据
+* @returns {*}  {boolean}
+*/
+function isCanCrop(node, store, item) {
+	let isDrop = true;
+	if (node) {
+		const nodes = store.getPaths(node.id);
+		if (nodes.findIndex((_) => _.id === item.id) !== -1) return false;
+		const providers = nodes.map((node) => {
+			return NodeRegister.get(node.type, store.prefix);
+		});
+		const whiteList = intersection(...providers.map((_) => _.whiteList).filter((_) => !!_));
+		const blackList = union(...providers.map((_) => _.blackList).filter((_) => !!_));
+		const strWhiteList = whiteList.filter((val) => typeof val === "string");
+		const regWhiteList = whiteList.filter((val) => val instanceof RegExp);
+		if (whiteList.length > 0) {
+			if (item.types.filter((_) => {
+				return regWhiteList.some((reg) => !reg.test(_)) && !strWhiteList.includes(_);
+			}).length > 0) isDrop = false;
+		}
+		if (isDrop === true && blackList.length > 0) {
+			let items = [];
+			if (whiteList.length > 0) items = item.types.filter((_) => {
+				return regWhiteList.some((reg) => reg.test(_)) || strWhiteList.includes(_);
+			});
+			else items = item.types;
+			const strBlackList = blackList.filter((val) => typeof val === "string");
+			const regBlackList = blackList.filter((val) => val instanceof RegExp);
+			const blacks = items.filter((_) => {
+				return regBlackList.some((reg) => reg.test(_));
+			});
+			if (intersection(strBlackList, items).length > 0 || blacks.length > 0) isDrop = false;
+		}
+	}
+	return isDrop;
+}
+//#endregion
+export { isCanCrop };

package/es/utils/design-plugin-pkg-util/design-plugin-pkg-util.d.ts

@@ -15,7 +15,7 @@ export declare class DesignPluginPgkUtil extends PluginPgkUtil {
      * @param {Platform} platform
      * @returns {*}  {Promise<LoadPluginResult>}
      */
-    static loadDesignPlugin(_app: App, _platform: Platform, _kit?: string[]): Promise<LoadPluginResult>;
+    static loadDesignPlugin(_app: App, platform: Platform, kit?: string[]): Promise<LoadPluginResult>;
     /**
      * 加载设计态中，已经被从配置中移除的插件
      *

package/es/utils/design-plugin-pkg-util/design-plugin-pkg-util.mjs

@@ -15,7 +15,35 @@ var DesignPluginPgkUtil = class extends PluginPgkUtil {
 	* @param {Platform} platform
 	* @returns {*}  {Promise<LoadPluginResult>}
 	*/
-	static async loadDesignPlugin(_app, _platform, _kit = []) {
+	static async loadDesignPlugin(_app, platform, kit = []) {
+		try {
+			const result = await this.loadPlugin(PluginModeEnum.DESIGN, platform, kit);
+			const [configs, moduleMap] = result;
+			configs.forEach((config) => {
+				config.plugins.forEach((plugin) => {
+					const module = moduleMap[plugin.key];
+					if (!module) {
+						console.error(`${plugin.key} 插件加载失败，请检查插件配置是否正确`);
+						return;
+					}
+					switch (platform) {
+						case Platform.MOBILE:
+							if (module.mobile) _gct.register.designer.mobile.register(plugin.key, () => new module.mobile());
+							break;
+						case Platform.PAD:
+							if (module.mobile) _gct.register.designer.pad.register(plugin.key, () => new module.mobile());
+							break;
+						case Platform.WEB:
+							if (module.web) _gct.register.designer.web.register(plugin.key, () => new module.web());
+							break;
+						default: console.warn(`未知平台 ${platform}，无法注册插件 ${plugin.key}`);
+					}
+				});
+			});
+			return result;
+		} catch (error) {
+			console.error(error);
+		}
 		return [[], {}];
 	}
 	/**

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

@@ -0,0 +1 @@
+export declare const asyncIdentify: import('@vueuse/core').UseMemoizeReturn<Promise<string[]>, [expr: string, isAll?: boolean | undefined]>;

package/es/utils/expression/index.mjs

@@ -0,0 +1,43 @@
+import { SYSTEM_VAR_PREFIX, functionMap, innerVarIds } from "@gct-paas/core";
+import { useMemoize } from "@vueuse/core";
+//#region src/utils/expression/index.ts
+var _esprima = null;
+var _estraverse = null;
+async function loadAstModules() {
+	if (!_esprima) [_esprima, _estraverse] = await Promise.all([import("esprima-next"), import("estraverse")]);
+	return {
+		esprima: _esprima,
+		estraverse: _estraverse.default || _estraverse
+	};
+}
+function _deepCalcName(esprima, node) {
+	if (node.type === esprima.Syntax.MemberExpression) return `${node.object.type === esprima.Syntax.MemberExpression ? _deepCalcName(esprima, node.object) : node.object.name}.${node.property.name}`;
+	else if (node.type === esprima.Syntax.Identifier) return node.name;
+	return "";
+}
+/**
+* 变量识别
+* @param expr
+* @returns
+*/
+async function _identify(expr, isAll = false) {
+	const { esprima, estraverse } = await loadAstModules();
+	const ast = esprima.parse(expr);
+	let identifiers = [];
+	estraverse.traverse(ast, { enter: function(node) {
+		if (node.type === esprima.Syntax.MemberExpression) {
+			const name = _deepCalcName(esprima, node);
+			identifiers.push(name);
+			Object.assign(node, {
+				name,
+				type: esprima.Syntax.Identifier
+			});
+		} else if (node.type === esprima.Syntax.Identifier) identifiers.push(node.name);
+		if (isAll) identifiers = identifiers.filter((item) => !functionMap[item] && item !== "undefined");
+		else identifiers = identifiers.filter((item) => !functionMap[item] && item !== "undefined" && !innerVarIds.includes(item) && !item.startsWith(SYSTEM_VAR_PREFIX) && !item.startsWith("undefined."));
+	} });
+	return [...new Set(identifiers)];
+}
+var asyncIdentify = useMemoize(_identify);
+//#endregion
+export { asyncIdentify };

package/es/utils/index.d.ts

@@ -1,5 +1,7 @@
+export { isCanCrop } from './can-drop/can-drop';
 export { designInterceptors } from './design-interceptors/design-interceptors';
 export { platform, designRegister } from './design-view';
+export { asyncIdentify } from './expression';
 export { basicAttrsUtils, transformField2Component } from './field-attrs';
 export { deptFilter, formulaFilter } from './field-filter';
 export { openFormulaEditorByDesign } from './formula-editor-design/formula-editor-design';

package/es/utils/index.mjs

@@ -1,5 +1,7 @@
+import "./can-drop/can-drop.mjs";
 import "./design-interceptors/design-interceptors.mjs";
 import "./design-view/index.mjs";
+import "./expression/index.mjs";
 import "./field-attrs/basicAttrs.mjs";
 import "./field-attrs/index.mjs";
 import "./field-filter/index.mjs";