@tmagic/editor 1.7.6 → 1.7.8-beta.1

package/dist/es/services/dataSource.js

@@ -0,0 +1,157 @@
+import BaseService_default from "./BaseService.js";
+import storage_default, { Protocol } from "./storage.js";
+import { COPY_DS_STORAGE_KEY } from "../utils/editor.js";
+import editor_default from "./editor.js";
+import { getFormConfig, getFormValue } from "../utils/data-source/index.js";
+import { guid, toLine } from "@tmagic/utils";
+import { Target, Watcher } from "@tmagic/core";
+import { reactive } from "vue";
+import { cloneDeep, get } from "lodash-es";
+//#region packages/editor/src/services/dataSource.ts
+var canUsePluginMethods = {
+	async: [],
+	sync: [
+		"getFormConfig",
+		"setFormConfig",
+		"getFormValue",
+		"setFormValue",
+		"getFormEvent",
+		"setFormEvent",
+		"getFormMethod",
+		"setFormMethod",
+		"add",
+		"update",
+		"remove",
+		"createId"
+	]
+};
+var DataSource = class extends BaseService_default {
+	state = reactive({
+		datasourceTypeList: [],
+		dataSources: [],
+		editable: true,
+		configs: {},
+		values: {},
+		events: {},
+		methods: {}
+	});
+	constructor() {
+		super(canUsePluginMethods.sync.map((methodName) => ({
+			name: methodName,
+			isAsync: false
+		})));
+	}
+	set(name, value) {
+		this.state[name] = value;
+	}
+	get(name) {
+		return this.state[name];
+	}
+	getFormConfig(type = "base") {
+		return getFormConfig(toLine(type), this.get("configs"));
+	}
+	setFormConfig(type, config) {
+		this.get("configs")[toLine(type)] = config;
+	}
+	getFormValue(type = "base") {
+		return getFormValue(toLine(type), this.get("values")[type]);
+	}
+	setFormValue(type, value) {
+		this.get("values")[toLine(type)] = value;
+	}
+	getFormEvent(type = "base") {
+		return this.get("events")[toLine(type)] || [];
+	}
+	setFormEvent(type, value = []) {
+		this.get("events")[toLine(type)] = value;
+	}
+	getFormMethod(type = "base") {
+		return this.get("methods")[toLine(type)] || [];
+	}
+	setFormMethod(type, value = []) {
+		this.get("methods")[toLine(type)] = value;
+	}
+	add(config) {
+		const newConfig = {
+			...config,
+			id: config.id && !this.getDataSourceById(config.id) ? config.id : this.createId()
+		};
+		this.get("dataSources").push(newConfig);
+		this.emit("add", newConfig);
+		return newConfig;
+	}
+	update(config, { changeRecords = [] } = {}) {
+		const dataSources = this.get("dataSources");
+		const index = dataSources.findIndex((ds) => ds.id === config.id);
+		const oldConfig = dataSources[index];
+		const newConfig = cloneDeep(config);
+		dataSources[index] = newConfig;
+		this.emit("update", newConfig, {
+			oldConfig,
+			changeRecords
+		});
+		return newConfig;
+	}
+	remove(id) {
+		const dataSources = this.get("dataSources");
+		const index = dataSources.findIndex((ds) => ds.id === id);
+		dataSources.splice(index, 1);
+		this.emit("remove", id);
+	}
+	createId() {
+		return `ds_${guid()}`;
+	}
+	getDataSourceById(id) {
+		return this.get("dataSources").find((ds) => ds.id === id);
+	}
+	resetState() {
+		this.set("dataSources", []);
+	}
+	destroy() {
+		this.removeAllListeners();
+		this.resetState();
+		this.removeAllPlugins();
+	}
+	usePlugin(options) {
+		super.usePlugin(options);
+	}
+	/**
+	* 复制时会带上组件关联的数据源
+	* @param config 组件节点配置
+	* @returns
+	*/
+	copyWithRelated(config, collectorOptions) {
+		const copyNodes = Array.isArray(config) ? config : [config];
+		const copyData = [];
+		if (collectorOptions && typeof collectorOptions.isTarget === "function") {
+			const customTarget = new Target({ ...collectorOptions });
+			const coperWatcher = new Watcher();
+			coperWatcher.addTarget(customTarget);
+			coperWatcher.collect(copyNodes, {}, true, collectorOptions.type);
+			Object.keys(customTarget.deps).forEach((nodeId) => {
+				const node = editor_default.getNodeById(nodeId);
+				if (!node) return;
+				customTarget.deps[nodeId].keys.forEach((key) => {
+					const [relateDsId] = get(node, key);
+					if (!copyData.find((dsItem) => dsItem.id === relateDsId)) {
+						const relateDs = this.getDataSourceById(relateDsId);
+						if (relateDs) copyData.push(relateDs);
+					}
+				});
+			});
+		}
+		storage_default.setItem(COPY_DS_STORAGE_KEY, copyData, { protocol: Protocol.OBJECT });
+	}
+	/**
+	* 粘贴数据源
+	* @returns
+	*/
+	paste() {
+		storage_default.getItem(COPY_DS_STORAGE_KEY).forEach((item) => {
+			if (!this.getDataSourceById(item.id)) this.add(item);
+		});
+	}
+};
+var dataSource_default = new DataSource();
+//#endregion
+export { dataSource_default as default };

package/dist/es/services/dep.js

@@ -0,0 +1,173 @@
+import BaseService_default from "./BaseService.js";
+import { IdleTask } from "../utils/dep/idle-task.js";
+import WorkerWrapper from "../utils/dep/worker.js";
+import { isPage } from "@tmagic/utils";
+import { DepTargetType, Watcher, traverseTarget } from "@tmagic/core";
+import { reactive, shallowReactive } from "vue";
+import { throttle } from "lodash-es";
+import serialize from "serialize-javascript";
+//#region packages/editor/src/services/dep.ts
+var Dep = class extends BaseService_default {
+	state = shallowReactive({
+		collecting: false,
+		taskLength: 0
+	});
+	idleTask = new IdleTask();
+	watcher = new Watcher({ initialTargets: reactive({}) });
+	waitingWorker;
+	constructor() {
+		super();
+		this.idleTask.on("update-task-length", throttle(({ length }) => {
+			this.set("taskLength", length);
+		}, 1e3));
+	}
+	set(name, value) {
+		this.state[name] = value;
+	}
+	get(name) {
+		return this.state[name];
+	}
+	removeTargets(type = DepTargetType.DEFAULT) {
+		this.watcher.removeTargets(type);
+		const targets = this.watcher.getTargets(type);
+		if (!targets) return;
+		for (const target of Object.values(targets)) this.emit("remove-target", target.id, type);
+	}
+	getTargets(type = DepTargetType.DEFAULT) {
+		return this.watcher.getTargets(type);
+	}
+	getTarget(id, type = DepTargetType.DEFAULT) {
+		return this.watcher.getTarget(id, type);
+	}
+	addTarget(target) {
+		this.watcher.addTarget(target);
+		this.emit("add-target", target);
+	}
+	removeTarget(id, type = DepTargetType.DEFAULT) {
+		this.watcher.removeTarget(id, type);
+		this.emit("remove-target", id, type);
+	}
+	clearTargets() {
+		this.watcher.clearTargets();
+	}
+	collect(nodes, depExtendedData = {}, deep = false, type) {
+		this.set("collecting", true);
+		this.watcher.collectByCallback(nodes, type, ({ node, target }) => {
+			this.collectNode(node, target, depExtendedData, deep);
+		});
+		this.set("collecting", false);
+		this.emit("collected", nodes, deep);
+		this.emit("ds-collected", nodes, deep);
+	}
+	async collectIdle(nodes, depExtendedData = {}, deep = false, type) {
+		if (this.waitingWorker) await this.waitingWorker;
+		this.set("collecting", true);
+		let startTask = false;
+		this.watcher.collectByCallback(nodes, type, ({ node, target }) => {
+			startTask = true;
+			this.enqueueTask(node, target, depExtendedData, deep);
+		});
+		return new Promise((resolve) => {
+			if (!startTask) {
+				this.emit("collected", nodes, deep);
+				this.set("collecting", false);
+				resolve();
+				return;
+			}
+			this.idleTask.once("finish", () => {
+				this.emit("collected", nodes, deep);
+				this.set("collecting", false);
+			});
+			this.idleTask.once("hight-level-finish", () => {
+				this.emit("ds-collected", nodes, deep);
+				resolve();
+			});
+		});
+	}
+	collectByWorker(dsl) {
+		this.set("collecting", true);
+		const { promise, resolve: waitingResolve } = Promise.withResolvers();
+		this.waitingWorker = promise;
+		return new Promise((resolve) => {
+			const worker = new WorkerWrapper();
+			worker.postMessage({ dsl: serialize(dsl) });
+			worker.onmessage = (e) => {
+				resolve(e.data);
+			};
+			worker.onerror = () => {
+				resolve({});
+			};
+		}).then((depsData) => {
+			traverseTarget(this.watcher.getTargetsList(), (target) => {
+				if (depsData[target.type]?.[target.id]) {
+					target.deps = reactive(depsData[target.type][target.id]);
+					if (target.type === DepTargetType.DATA_SOURCE && dsl.dataSourceDeps) dsl.dataSourceDeps[target.id] = target.deps;
+					else if (target.type === DepTargetType.DATA_SOURCE_COND && dsl.dataSourceCondDeps) dsl.dataSourceCondDeps[target.id] = target.deps;
+					else if (target.type === DepTargetType.DATA_SOURCE_METHOD) dsl.dataSourceMethodDeps[target.id] = target.deps;
+				}
+			});
+			this.set("collecting", false);
+			this.emit("collected", dsl.items, true);
+			this.emit("ds-collected", dsl.items, true);
+			waitingResolve();
+			return depsData;
+		});
+	}
+	collectNode(node, target, depExtendedData = {}, deep = false) {
+		if (isPage(node)) {
+			for (const [depKey, dep] of Object.entries(target.deps)) if (dep.data?.pageId && dep.data.pageId === depExtendedData.pageId) delete target.deps[depKey];
+		} else this.watcher.removeTargetDep(target, node);
+		this.watcher.collectItem(node, target, depExtendedData, deep);
+	}
+	clear(nodes) {
+		return this.watcher.clear(nodes);
+	}
+	clearByType(type, nodes) {
+		return this.watcher.clearByType(type, nodes);
+	}
+	hasTarget(id, type = DepTargetType.DEFAULT) {
+		return this.watcher.hasTarget(id, type);
+	}
+	hasSpecifiedTypeTarget(type = DepTargetType.DEFAULT) {
+		return this.watcher.hasSpecifiedTypeTarget(type);
+	}
+	clearIdleTasks() {
+		this.idleTask.clearTasks();
+	}
+	on(eventName, listener) {
+		return super.on(eventName, listener);
+	}
+	once(eventName, listener) {
+		return super.once(eventName, listener);
+	}
+	reset() {
+		this.idleTask.clearTasks();
+		for (const type of Object.keys(this.watcher.getTargetsList())) this.removeTargets(type);
+		this.set("collecting", false);
+	}
+	destroy() {
+		this.idleTask.removeAllListeners();
+		this.removeAllListeners();
+		this.reset();
+		this.removeAllPlugins();
+		this.idleTask.removeAllListeners();
+	}
+	emit(eventName, ...args) {
+		return super.emit(eventName, ...args);
+	}
+	enqueueTask(node, target, depExtendedData, deep) {
+		this.idleTask.enqueueTask(({ node, deep, target }) => {
+			this.collectNode(node, target, depExtendedData, deep);
+		}, {
+			node,
+			deep: false,
+			target
+		}, target.type === DepTargetType.DATA_SOURCE);
+		if (deep && Array.isArray(node.items) && node.items.length) node.items.forEach((item) => {
+			this.enqueueTask(item, target, depExtendedData, deep);
+		});
+	}
+};
+var dep_default = new Dep();
+//#endregion
+export { dep_default as default };