@gct-paas/design 0.1.5-dev.6 → 0.1.5-dev.8

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

@@ -1,3 +1,4 @@
+export { isCanCrop } from './can-drop/can-drop';
 export { designInterceptors } from './design-interceptors/design-interceptors';
 export { platform, designRegister } from './design-view';
 export { asyncIdentify } from './expression';

package/es/utils/index.mjs

@@ -1,3 +1,4 @@
+import "./can-drop/can-drop.mjs";
 import "./design-interceptors/design-interceptors.mjs";
 import "./design-view/index.mjs";
 import "./expression/index.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gct-paas/design",
-  "version": "0.1.5-dev.6",
+  "version": "0.1.5-dev.8",
   "type": "module",
   "description": "paas 平台设计界面底包",
   "loader": "dist/loader.esm.min.js",
@@ -34,12 +34,13 @@
     "@ant-design/icons-vue": "^7.0.1",
     "@babel/core": "^7.29.0",
     "@babel/standalone": "^7.29.2",
-    "@gct-paas/api": "0.1.4-dev.0",
+    "@gct-paas/api": "0.1.4-dev.3",
     "@jsplumb/browser-ui": "^6.2.10",
     "@vueuse/core": "^14.1.0",
     "ant-design-vue": "~3.2.20",
     "async-validator": "^4.2.5",
     "axios": "^1.13.2",
+    "colord": "^2.9.3",
     "dayjs": "^1.11.19",
     "escodegen": "^2.1.0",
     "esprima-next": "5.8.4",
@@ -50,10 +51,10 @@
     "react-dnd-html5-backend": "^16.0.1",
     "vue": "^3.5.30",
     "vue3-dnd": "^2.1.0",
-    "@gct-paas/scss": "0.1.5-dev.6",
-    "@gct-paas/core": "0.1.5-dev.6",
-    "@gct-paas/schema": "0.1.5-dev.6",
-    "@gct-paas/core-web": "0.1.5-dev.6"
+    "@gct-paas/core": "0.1.5-dev.8",
+    "@gct-paas/core-web": "0.1.5-dev.8",
+    "@gct-paas/scss": "0.1.5-dev.8",
+    "@gct-paas/schema": "0.1.5-dev.8"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
@@ -61,12 +62,12 @@
     "@types/estraverse": "^5.1.7"
   },
   "peerDependencies": {
-    "@gct-paas/api": "0.1.4-dev.0",
+    "@gct-paas/api": "0.1.4-dev.3",
     "vue": ">=3",
-    "@gct-paas/core-web": "0.1.5-dev.6",
-    "@gct-paas/schema": "0.1.5-dev.6",
-    "@gct-paas/core": "0.1.5-dev.6",
-    "@gct-paas/scss": "0.1.5-dev.6"
+    "@gct-paas/core-web": "0.1.5-dev.8",
+    "@gct-paas/core": "0.1.5-dev.8",
+    "@gct-paas/schema": "0.1.5-dev.8",
+    "@gct-paas/scss": "0.1.5-dev.8"
   },
   "scripts": {
     "dev": "cross-env NODE_ENV=development vite build --watch --config vite.dev.config.ts",

package/es/components/field-cascader/index.d.ts

@@ -1,2 +0,0 @@
-import { default as FieldCascader } from './src/FieldCascader.vue';
-export { FieldCascader };

package/es/components/field-cascader/index.mjs

@@ -1 +0,0 @@
-import "./src/FieldCascader.vue.mjs";

package/es/components/field-cascader/src/FieldCascader.vue.d.ts

@@ -1,87 +0,0 @@
-import { PropType } from 'vue';
-import { comPropsType } from './hooks';
-declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    fieldMetaList: {
-        type: PropType<comPropsType["fieldMetaList"]>;
-        default: () => comPropsType["fieldMetaList"];
-    };
-    filterFieldByFunction: {
-        type: FunctionConstructor;
-        default: () => boolean;
-    };
-    maxLevel: {
-        type: NumberConstructor;
-        default: number;
-    };
-    value: {
-        type: StringConstructor;
-        default: string;
-    };
-    allowClear: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    valueSeparator: {
-        type: StringConstructor;
-        default: string;
-    };
-    searchable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    expandToLeft: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    FieldClick: (...args: any[]) => void;
-    labelChange: (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    fieldMetaList: {
-        type: PropType<comPropsType["fieldMetaList"]>;
-        default: () => comPropsType["fieldMetaList"];
-    };
-    filterFieldByFunction: {
-        type: FunctionConstructor;
-        default: () => boolean;
-    };
-    maxLevel: {
-        type: NumberConstructor;
-        default: number;
-    };
-    value: {
-        type: StringConstructor;
-        default: string;
-    };
-    allowClear: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    valueSeparator: {
-        type: StringConstructor;
-        default: string;
-    };
-    searchable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    expandToLeft: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{
-    onFieldClick?: ((...args: any[]) => any) | undefined;
-    onLabelChange?: ((...args: any[]) => any) | undefined;
-}>, {
-    fieldMetaList: (import('@gct-paas/api/apaas').FieldMetaDTO & {
-        __bindFields: string[];
-    })[];
-    filterFieldByFunction: Function;
-    maxLevel: number;
-    value: string;
-    allowClear: boolean;
-    valueSeparator: string;
-    searchable: boolean;
-    expandToLeft: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-export default _default;

package/es/components/field-cascader/src/FieldCascader.vue.mjs

@@ -1,6 +0,0 @@
-import FieldCascader_vue_vue_type_script_setup_true_lang_default from "./FieldCascader.vue_vue_type_script_setup_true_lang.mjs";
-import './FieldCascader.vue_vue_type_style_index_0_lang.css';/* empty css                                                    */
-//#region src/components/field-cascader/src/FieldCascader.vue
-var FieldCascader_default = FieldCascader_vue_vue_type_script_setup_true_lang_default;
-//#endregion
-export { FieldCascader_default as default };