x-runtime-lib 0.8.198 → 0.8.200

package/dist/element/ui/dataTable/v1/spawn.d.ts

@@ -1,2 +1,2 @@
-import { NodePair } from "@/types";
+import { NodePair } from '@/types';
 export declare function spawn(type: string, subtype: string): NodePair | undefined;

package/dist/index.js

@@ -1,6 +1,6 @@
 import { n as __export } from "./rolldown-runtime.ofrncwta.js";
 import { C as MapControls_default, D as isEmpty_default, E as isEqual_default, O as cloneDeep_default, S as KeyboardControls_default, T as component_default$8, _ as install, b as registerTheme, d as install$5, f as install$4, g as install$3, h as install$1, i as getQuickJS, k as capitalize_default, l as encodeString, m as install$2, p as install$6, r as mitt_default, u as install$7, v as core_exports, w as OrbitControls_default, x as HTML_default, y as use } from "./vendor.pfrgnj2n.js";
-import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createVNode, defineComponent, h, inject, isRef, mergeModels, nextTick, normalizeClass, normalizeStyle, onBeforeMount, onMounted, onUnmounted, openBlock, provide, readonly, ref, renderList, renderSlot, resolveComponent, toDisplayString, unref, useAttrs, useId, useModel, useTemplateRef, watch, watchEffect, withCtx, withModifiers } from "vue";
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createVNode, defineComponent, h, inject, isRef, mergeModels, nextTick, normalizeClass, normalizeStyle, onBeforeMount, onMounted, onUnmounted, openBlock, provide, readonly, ref, renderList, renderSlot, resolveComponent, shallowRef, toDisplayString, unref, useAttrs, useId, useModel, useTemplateRef, watch, watchEffect, withCtx, withModifiers } from "vue";
 import { createAxios, eventBus, getTypeDefault, globalObjects, messageError, messageInfo, messageSuccess, messageWarning, openConfirmDlg, openPromptDlg, useViewStack, waitUtil } from "x-essential-lib";
 import { CameraHelper, DirectionalLightHelper, PointLightHelper, SpotLightHelper } from "three";
 import { useTheme as useTheme$1 } from "vuetify";
@@ -1500,7 +1500,7 @@ function useElementSlotProperty(e, p, m, g) {
 	}), onUnmounted(() => {
 		e.eventBus.off(`property/${m}/get`, _), e.eventBus.off(`property/${m}/set`, v);
 	}), watch(g, (g, _) => {
-		e.hooks.onPropertyChange(makePropertyId("elementAdaptSlotProperty", "globality", makePropertyKeyOfElementSlot(p.value.basic.key, e.slotId, m)), g, _, e.instance), e.parent && e.parent.hooks.onPropertyChange(makePropertyId("elementSlotProperty", e.nodeId, makePropertyKeyOfElementSlot(p.value.basic.key, e.slotId, m)), g, _, e.instance);
+		e.hooks.onPropertyChange(makePropertyId("elementAdaptSlotProperty", "globality", makePropertyKeyOfElementSlot(p.value.basic.key, e.slotId, m)), g, _, e.instance);
 	}, { immediate: !0 });
 }
 function useElementSlotRender(e, p, m) {
@@ -3394,7 +3394,7 @@ var echarts_default = core_exports, v1_default$49 = /* @__PURE__ */ defineCompon
 			"addIcon",
 			"prepend"
 		]), { property: N } = useElementProperty(m, ["settings", "readonly"]), { property: P } = useElementProperty(m, ["settings", "ripple"]), { property: F } = useElementProperty(m, ["settings", "size"]), { property: I } = useElementProperty(m, ["settings", "stacked"]), { property: L } = useElementProperty(m, ["settings", "text"]), { theme: R } = useTheme(), { property: z } = useElementProperty(m, ["settings", "variant"]), { property: B } = useElementProperty(m, ["size", "width"]), V = async (e) => {
-			!g || !g.vm || (g.setGlobalVariable("__pointerPosX__", e.clientX), g.setGlobalVariable("__pointerPosY__", e.clientY), await g.callFunctionAsync("__triggerEventV1__", makeEventId("elementEvent", p.nodeId, "click"), ""));
+			!g || !g.vm || (g.setGlobalVariable("__pointerPosX__", e.clientX), g.setGlobalVariable("__pointerPosY__", e.clientY), await g.triggerEvent(makeEventId("elementEvent", p.nodeId, "click"), []));
 		};
 		return (e, p) => {
 			let m = resolveComponent("v-btn");
@@ -4035,7 +4035,7 @@ var v1_default$40 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 			let e = {}, p = _.value?.type;
 			return g === "page" ? p === "ui" ? (E(e), D(e), O(e), k(e), T.value && (e.backgroundColor = T.value)) : console.assert(!1) : g === "comp" && p === "ui" ? (E(e), D(e), O(e), k(e), T.value && (e.backgroundColor = T.value)) : console.assert(!1), e;
 		}), j = async () => {
-			await v?.callFunctionAsync("__triggerEventV1__", makeEventId("elementEvent", p.nodeId, "submit"), "");
+			!v || !v.vm || await v.triggerEvent(makeEventId("elementEvent", p.nodeId, "submit"), []);
 		};
 		return (e, p) => {
 			let m = resolveComponent("v-form");
@@ -10545,9 +10545,9 @@ function bindView(e) {
 		return;
 	}
 	let { vm: p } = e;
-	p.newFunction("__triggerEventV1__", (m, g, ..._) => {
-		let v = p.getString(m), y = p.getString(g), b = _.map((e) => p.dump(e)), { promise: x, resolve: S, reject: C } = e.promiseManager.create();
-		return e.triggerEvent(v, y, ...b).then((e) => S(e), (e) => C(e)), x.settled.then(p.runtime.executePendingJobs), x.handle;
+	p.newFunction("__triggerEventV1__", (m, g, _) => {
+		let v = p.getString(m), y = p.dump(g), b = p.getString(_), { promise: x, resolve: S, reject: C } = e.promiseManager.create();
+		return e.triggerEvent(v, y, b).then((e) => S(e), (e) => C(e)), x.settled.then(p.runtime.executePendingJobs), x.handle;
 	}).consume((e) => p.setProp(p.global, "__triggerEventV1__", e)), p.newFunction("__getPropertyV1__", (m, g) => {
 		let _ = p.getString(m), v = p.getString(g), { promise: y, resolve: b, reject: x } = e.promiseManager.create();
 		return e.getProperty(_, v).then((e) => b(e), (e) => x(e)), y.settled.then(p.runtime.executePendingJobs), y.handle;
@@ -10616,7 +10616,7 @@ var PromiseManager = class {
 				this.vm && (newAny(this.vm, m).consume((e) => p.resolve(e)), delete this.promises[e]);
 			},
 			reject: (m) => {
-				this.vm && (newAny(this.vm, m).consume((e) => p.reject(e)), delete this.promises[e]);
+				this.vm && (m instanceof Error && (m = m.message), newAny(this.vm, m).consume((e) => p.reject(e)), delete this.promises[e]);
 			}
 		};
 	}
@@ -10655,14 +10655,15 @@ var PromiseManager = class {
 	}
 	meta = ref();
 	data = ref();
-	prepare(e, p, m) {
-		this.meta.value = e.value, this.data.value = p.value, this.resetProperties(m), this.resetStates();
+	depends = shallowRef();
+	prepare(e, p, m, g) {
+		this.meta.value = e.value, this.data.value = p.value, this.depends.value = m.value, this.resetProperties(g), this.resetStates();
 	}
 	getNode(e) {
 		return this.data.value?.view.nodes[e];
 	}
 	async createVm(e, p) {
-		this.vm = e.newContext(), this.promiseManager = new PromiseManager(this.vm), bind(this), this.vm.evalCode("\nlet __events__ = {}\n\nfunction __onEventV1__(id, callback) {\n  if (typeof(id) !== 'string' || !id) {\n    return\n  }\n  if (typeof(callback) !== 'function') {\n    return\n  }\n  if (!__events__[id]) {\n    __events__[id] = []\n  }\n  const callbacks = __events__[id]\n  for (let i = 0; i < callbacks.length; i++) {\n    if (callbacks[i] === callback) {\n      return\n    }\n  }\n  callbacks.push(callback)\n}\n\nasync function __triggerEventInner__(id, ...params) {\n  if (typeof(id) !== 'string' || !id) {\n    return\n  }\n  if (!__events__[id]) {\n    return\n  }\n  const callbacks = __events__[id]\n  if (!callbacks) {\n    return\n  }\n  for (let i = 0; i < callbacks.length; i++) {\n    await callbacks[i](...params)\n  }\n}\n\nlet __timers__ = {}\nlet __currTimerId__ = 0\n\nfunction __createTimerV1__(interval, loop, count, immediate, callback) {\n  if (!loop && count <= 0) {\n    return\n  }\n  const timer = {}\n  timer.id = __currTimerId__++\n  timer.interval = interval\n  timer.loop = loop\n  timer.count = count\n  timer.immediate = immediate\n  timer.callback = callback\n  __timers__[timer.id] = timer\n  if (timer.immediate) {\n    __timeoutCallbackV1__(timer.id)\n  } else {\n    __timeoutV1__(timer.id, timer.interval)\n  }\n}\n\nasync function __timeoutCallback__(timerId) {\n  const timer = __timers__[timerId]\n  if (timer) {\n    timer.callback()\n    // 修改计数\n    if (!timer.loop) {\n      timer.count = timer.count - 1\n    }\n    // 触发超时\n    if (timer.loop || timer.count > 0) {\n      await __timeoutV1__(timer.id, timer.interval)\n    }\n    // 回收\n    if (!timer.loop && timer.count <= 0) {\n      delete __timers__[timer.id]\n    }\n  }\n}\n\nfunction __destroy__() {\n  __events__ = {}\n  __timers__ = {}\n}\n"), this.setGlobalVariable("__env__", this.env), this.vm.evalCode(p), await nextTick(), this.hooks.onReady();
+		this.vm = e.newContext(), this.promiseManager = new PromiseManager(this.vm), bind(this), this.vm.evalCode("\nlet __events__ = {}\n\nfunction __onEventV1__(id, callback) {\n  if (typeof(id) !== 'string' || !id) {\n    return\n  }\n  if (typeof(callback) !== 'function') {\n    return\n  }\n  if (!__events__[id]) {\n    __events__[id] = []\n  }\n  const callbacks = __events__[id]\n  for (let i = 0; i < callbacks.length; i++) {\n    if (callbacks[i] === callback) {\n      return\n    }\n  }\n  callbacks.push(callback)\n}\n\nasync function __triggerEventInner__(id, params, instance) {\n  if (!__events__[id]) {\n    return\n  }\n  const callbacks = __events__[id]\n  if (!callbacks) {\n    return\n  }\n  for (let i = 0; i < callbacks.length; i++) {\n    await callbacks[i](params, instance)\n  }\n}\n\nlet __timers__ = {}\nlet __currTimerId__ = 0\n\nfunction __createTimerV1__(interval, loop, count, immediate, callback) {\n  if (!loop && count <= 0) {\n    return\n  }\n  const timer = {}\n  timer.id = __currTimerId__++\n  timer.interval = interval\n  timer.loop = loop\n  timer.count = count\n  timer.immediate = immediate\n  timer.callback = callback\n  __timers__[timer.id] = timer\n  if (timer.immediate) {\n    __timeoutCallbackV1__(timer.id)\n  } else {\n    __timeoutV1__(timer.id, timer.interval)\n  }\n}\n\nasync function __timeoutCallback__(timerId) {\n  const timer = __timers__[timerId]\n  if (timer) {\n    timer.callback()\n    // 修改计数\n    if (!timer.loop) {\n      timer.count = timer.count - 1\n    }\n    // 触发超时\n    if (timer.loop || timer.count > 0) {\n      await __timeoutV1__(timer.id, timer.interval)\n    }\n    // 回收\n    if (!timer.loop && timer.count <= 0) {\n      delete __timers__[timer.id]\n    }\n  }\n}\n\nfunction __destroy__() {\n  __events__ = {}\n  __timers__ = {}\n}\n"), this.setGlobalVariable("__env__", this.env), this.vm.evalCode(p), await nextTick(), this.hooks.onReady();
 	}
 	destroyVm() {
 		this.vm && this.hooks.onDestroy(), this.promiseManager &&= (this.promiseManager.dispose(), void 0), this.vm &&= (this.vm.dispose(), void 0);
@@ -10722,27 +10723,160 @@ var PromiseManager = class {
 	isValidOfCustomEvent(e) {
 		return this.meta.value ? !!this.meta.value.events?.find((p) => p.id === e) : !1;
 	}
-	isValidOfCustomSlotEvent(e, p) {
-		if (!this.meta.value) return !1;
-		let m = this.meta.value.slots?.find((p) => p.id === e);
-		return !m || !m.events ? !1 : !!m.events.find((e) => e.id === p);
-	}
-	async triggerEvent(e, p, ...m) {
-		this.debugTrace("triggerEvent", e, p, ...m);
-		let { kind: g, nodeId: _, eventKey: v } = unwrapEventId(e);
-		if (await this.callFunctionAsync("__triggerEventInner__", e, p, ...m), g === "elementSlotEvent") {
-			let e = this.children[_];
-			e && await e.triggerEvent(makeEventId("elementAdaptSlotEvent", "globality", v), "", ...m);
-		} else if (g === "multipleElementSlotEvent") {
-			let e = this.children[`${_}/${p}`];
-			e && await e.triggerEvent(makeEventId("elementAdaptSlotEvent", "globality", v), "", ...m);
-		} else if (g === "customSlotEvent") {
-			let e = this.children[_];
-			e && await e.triggerEvent(makeEventId("customAdaptSlotEvent", "globality", v), "", ...m);
-		} else if (g === "multipleCustomSlotEvent") {
-			let e = this.children[`${_}/${p}`];
-			e && await e.triggerEvent(makeEventId("customAdaptSlotEvent", "globality", v), "", ...m);
-		} else g === "customEvent" && this.parent && (await this.parent.triggerEvent(makeEventId("refEvent", this.nodeId, v), "", ...m), await this.parent.triggerEvent(makeEventId("multipleRefEvent", this.nodeId, v), this.instance, ...m));
+	isValidOfCustomSlotEvent(e, p, m) {
+		let g = this.depends.value?.[e];
+		if (!g) return !1;
+		let _ = g.meta.slots?.find((e) => e.id === p);
+		return !_ || !_.events ? !1 : !!_.events.find((e) => e.id === m);
+	}
+	async triggerEvent(e, p, m) {
+		this.debugTrace("triggerEvent", e, p, m);
+		let { kind: g, nodeId: _, eventKey: v } = unwrapEventId(e), y = this.getNode(_);
+		if (!y) throw Error("node not found");
+		if (g === "elementEvent") await this.triggerElementEvent(e, p, y, v);
+		else if (g === "elementPropertyChangeEvent") await this.triggerElementPropertyChangeEvent(e, p, y, v);
+		else if (g === "elementSlotEvent") await this.triggerElementSlotEvent(e, p, _, v);
+		else if (g === "elementSlotPropertyChangeEvent") await this.triggerElementSlotPropertyChangeEvent(e, p, v);
+		else if (g === "multipleElementSlotEvent") await this.triggerMultipleElementSlotEvent(e, p, _, v, m);
+		else if (g === "multipleElementSlotPropertyChangeEvent") await this.triggerMultipleElementSlotPropertyChangeEvent(e, p, v, m);
+		else if (g === "refEvent") await this.triggerRefEvent(e, p, _, v);
+		else if (g === "refPropertyChangeEvent") await this.triggerRefPropertyChangeEvent(e, p, _, v);
+		else if (g === "multipleRefEvent") await this.triggerMultipleRefEvent(e, p, _, v, m);
+		else if (g === "multipleRefPropertyChangeEvent") await this.triggerMultipleRefPropertyChangeEvent(e, p, _, v, m);
+		else if (g === "customSlotEvent") await this.triggerCustomSlotEvent(e, p, _, v);
+		else if (g === "customSlotPropertyChangeEvent") await this.triggerCustomSlotPropertyChangeEvent(e, p, v);
+		else if (g === "multipleCustomSlotEvent") await this.triggerMultipleCustomSlotEvent(e, p, _, v, m);
+		else if (g === "multipleCustomSlotPropertyChangeEvent") await this.triggerMultipleCustomSlotPropertyChangeEvent(e, p, v, m);
+		else if (g === "customEvent") await this.triggerCustomEvent(e, p, v);
+		else if (g === "customPropertyChangeEvent") await this.triggerCustomPropertyChangeEvent(e, p, v);
+		else if (g === "elementAdaptSlotEvent") await this.triggerElementAdaptSlotEvent(e, p, v);
+		else if (g === "elementAdaptSlotPropertyChangeEvent") await this.triggerElementAdaptSlotPropertyChangeEvent(e, p, v);
+		else if (g === "customAdaptSlotEvent") await this.triggerCustomAdaptSlotEvent(e, p, v);
+		else if (g === "customAdaptSlotPropertyChangeEvent") await this.triggerCustomAdaptSlotPropertyChangeEvent(e, p, v);
+		else if (g === "stateChangeEvent") await this.triggerStateChangeEvent(e, p, v);
+		else throw Error("not implemented event kind");
+	}
+	async triggerElementEvent(e, p, m, g) {
+		if (!this.isValidOfElementEvent(m.basic.key, g)) throw Error("invalid element event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerElementPropertyChangeEvent(e, p, m, g) {
+		if (!this.isValidOfElementProperty(m.basic.key, g)) throw Error("invalid element property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerElementSlotEvent(e, p, m, g) {
+		let { elementKey: _, slotKey: v, eventKey: y } = unwrapEventKeyOfElementSlot(g);
+		if (!this.isValidOfElementSlotEvent(_, v, y)) throw Error("invalid element slot event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+		let b = this.children[m];
+		b && await b.triggerEvent(makeEventId("elementAdaptSlotEvent", "globality", g), p);
+	}
+	async triggerElementSlotPropertyChangeEvent(e, p, m) {
+		let { elementKey: g, slotKey: _, eventKey: v } = unwrapEventKeyOfElementSlot(m);
+		if (!this.isValidOfElementSlotProperty(g, _, v)) throw Error("invalid element slot property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerMultipleElementSlotEvent(e, p, m, g, _) {
+		if (!_) throw Error("instance not available");
+		let { elementKey: v, slotKey: y, eventKey: b } = unwrapEventKeyOfElementSlot(g);
+		if (!this.isValidOfElementSlotEvent(v, y, b)) throw Error("invalid element slot event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p, _);
+		let x = this.children[`${m}/${_}`];
+		x && await x.triggerEvent(makeEventId("elementAdaptSlotEvent", "globality", g), p);
+	}
+	async triggerMultipleElementSlotPropertyChangeEvent(e, p, m, g) {
+		if (!g) throw Error("instance not available");
+		let { elementKey: _, slotKey: v, eventKey: y } = unwrapEventKeyOfElementSlot(m);
+		if (!this.isValidOfElementSlotProperty(_, v, y)) throw Error("invalid element slot property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p, g);
+	}
+	async triggerRefEvent(e, p, m, g) {
+		let _ = this.children[m];
+		if (!_) throw Error("sandbox not found");
+		if (!_.isValidOfCustomEvent(g)) throw Error("invalid custom event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerRefPropertyChangeEvent(e, p, m, g) {
+		let _ = this.children[m];
+		if (!_) throw Error("sandbox not found");
+		if (!_.isValidOfCustomProperty(g)) throw Error("invalid custom property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerMultipleRefEvent(e, p, m, g, _) {
+		if (!_) throw Error("instance not available");
+		let v = this.children[`${m}/${_}`];
+		if (!v) throw Error("sandbox not found");
+		if (!v.isValidOfCustomEvent(g)) throw Error("invalid custom event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p, _);
+	}
+	async triggerMultipleRefPropertyChangeEvent(e, p, m, g, _) {
+		if (!_) throw Error("instance not available");
+		let v = this.children[`${m}/${_}`];
+		if (!v) throw Error("sandbox not found");
+		if (!v.isValidOfCustomProperty(g)) throw Error("invalid custom property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p, _);
+	}
+	async triggerCustomSlotEvent(e, p, m, g) {
+		let { compId: _, slotId: v, eventId: y } = unwrapEventKeyOfCustomSlot(g);
+		if (!this.isValidOfCustomSlotEvent(_, v, y)) throw Error("invalid custom slot event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+		let b = this.children[m];
+		b && await b.triggerEvent(makeEventId("customAdaptSlotEvent", "globality", g), p);
+	}
+	async triggerCustomSlotPropertyChangeEvent(e, p, m) {
+		let { compId: g, slotId: _, eventId: v } = unwrapEventKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotProperty(g, _, v)) throw Error("invalid custom slot property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerMultipleCustomSlotEvent(e, p, m, g, _) {
+		if (!_) throw Error("instance not available");
+		let { compId: v, slotId: y, eventId: b } = unwrapEventKeyOfCustomSlot(g);
+		if (!this.isValidOfCustomSlotEvent(v, y, b)) throw Error("invalid custom slot event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p, _);
+		let x = this.children[`${m}/${_}`];
+		x && await x.triggerEvent(makeEventId("customAdaptSlotEvent", "globality", g), p);
+	}
+	async triggerMultipleCustomSlotPropertyChangeEvent(e, p, m, g) {
+		if (!g) throw Error("instance not available");
+		let { compId: _, slotId: v, eventId: y } = unwrapEventKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotProperty(_, v, y)) throw Error("invalid custom slot property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p, g);
+	}
+	async triggerCustomEvent(e, p, m) {
+		if (!this.isValidOfCustomEvent(m)) throw Error("invalid custom event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p), this.parent && (await this.parent.triggerEvent(makeEventId("refEvent", this.nodeId, m), p), await this.parent.triggerEvent(makeEventId("multipleRefEvent", this.nodeId, m), p, this.instance));
+	}
+	async triggerCustomPropertyChangeEvent(e, p, m) {
+		if (!this.isValidOfCustomProperty(m)) throw Error("invalid custom property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerElementAdaptSlotEvent(e, p, m) {
+		if (!this.parent) throw Error("not in slot");
+		let { elementKey: g, slotKey: _, eventKey: v } = unwrapEventKeyOfElementSlot(m);
+		if (!this.isValidOfElementSlotEvent(g, _, v)) throw Error("invalid element slot event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerElementAdaptSlotPropertyChangeEvent(e, p, m) {
+		if (!this.parent) throw Error("not in slot");
+		let { elementKey: g, slotKey: _, eventKey: v } = unwrapEventKeyOfElementSlot(m);
+		if (!this.isValidOfElementSlotProperty(g, _, v)) throw Error("invalid element slot property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerCustomAdaptSlotEvent(e, p, m) {
+		if (!this.parent) throw Error("not in slot");
+		let { compId: g, slotId: _, eventId: v } = unwrapEventKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotEvent(g, _, v)) throw Error("invalid custom slot event");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerCustomAdaptSlotPropertyChangeEvent(e, p, m) {
+		if (!this.parent) throw Error("not in slot");
+		let { compId: g, slotId: _, eventId: v } = unwrapEventKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotProperty(g, _, v)) throw Error("invalid custom slot property");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerStateChangeEvent(e, p, m) {
+		if (!this.isValidOfState(m)) throw Error("invalid state");
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
 	}
 	customProperties = {};
 	customSlotProperties = {};
@@ -10767,17 +10901,16 @@ var PromiseManager = class {
 	isValidOfCustomProperty(e) {
 		return this.meta.value ? !!this.meta.value.properties?.find((p) => p.id === e) : !1;
 	}
-	isValidOfCustomSlotProperty(e, p) {
-		if (!this.meta.value) return !1;
-		let m = this.meta.value.slots?.find((p) => p.id === e);
-		return !m || !m.properties ? !1 : !!m.properties.find((e) => e.id === p);
+	isValidOfCustomSlotProperty(e, p, m) {
+		let g = this.depends.value?.[e];
+		if (!g) return !1;
+		let _ = g.meta.slots?.find((e) => e.id === p);
+		return !_ || !_.properties ? !1 : !!_.properties.find((e) => e.id === m);
 	}
 	async getProperty(e, p) {
 		let { kind: m, nodeId: g, propertyKey: _ } = unwrapPropertyId(e), v = this.getNode(g);
 		if (!v) throw Error("node not found");
 		if (m === "elementProperty") return await this.getElementProperty(e, v, _);
-		if (m === "elementSlotProperty") return await this.getElementSlotProperty(e, g, _);
-		if (m === "multipleElementSlotProperty") return await this.getMultipleElementSlotProperty(e, g, _, p);
 		if (m === "refProperty") return await this.getRefProperty(e, g, _);
 		if (m === "multipleRefProperty") return await this.getMultipleRefProperty(e, g, _, p);
 		if (m === "customSlotProperty") return await this.getCustomSlotProperty(e, g, _);
@@ -10791,21 +10924,6 @@ var PromiseManager = class {
 		if (!this.isValidOfElementProperty(p.basic.key, m)) throw console.warn(`Sandbox/getElementProperty invalid element property id=${e}`), Error("invalid element property");
 		return getField(p, m);
 	}
-	async getElementSlotProperty(e, p, m) {
-		let { elementKey: g, slotKey: _, propertyKey: v } = unwrapPropertyKeyOfElementSlot(m), y = this.children[`${p}/${_}`];
-		if (!y) throw Error("sandbox not found");
-		if (!y.isValidOfElementSlotProperty(g, _, v)) throw console.warn(`Sandbox/getElementSlotProperty invalid element slot property id=${e}`), Error("invalid element slot property");
-		let b = { value: void 0 };
-		return y.eventBus.emit(`property/${v}/get`, { result: b }), b.value;
-	}
-	async getMultipleElementSlotProperty(e, p, m, g) {
-		if (!g) throw Error("instance not available");
-		let { elementKey: _, slotKey: v, propertyKey: y } = unwrapPropertyKeyOfElementSlot(m), b = this.children[`${p}/${v}/${g}`];
-		if (!b) throw Error("sandbox not found");
-		if (!b.isValidOfElementSlotProperty(_, v, y)) throw console.warn(`Sandbox/getMultipleElementSlotProperty invalid element slot property id=${e}`), Error("invalid element slot property");
-		let x = { value: void 0 };
-		return b.eventBus.emit(`property/${y}/get`, { result: x }), x.value;
-	}
 	async getRefProperty(e, p, m) {
 		let g = this.children[p];
 		if (!g) throw Error("sandbox not found");
@@ -10820,17 +10938,19 @@ var PromiseManager = class {
 		return _.customProperties[m];
 	}
 	async getCustomSlotProperty(e, p, m) {
-		let { slotId: g, propertyId: _ } = unwrapPropertyKeyOfCustomSlot(m), v = this.children[p];
-		if (!v) throw Error("sandbox not found");
-		if (!v.isValidOfCustomSlotProperty(g, _)) throw console.warn(`Sandbox/getCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
-		return v.customSlotProperties[_];
+		let { compId: g, slotId: _, propertyId: v } = unwrapPropertyKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotProperty(g, _, v)) throw console.warn(`Sandbox/getCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
+		let y = this.children[p];
+		if (!y) throw Error("sandbox not found");
+		return y.customSlotProperties[v];
 	}
 	async getMultipleCustomSlotProperty(e, p, m, g) {
 		if (!g) throw Error("instance not available");
-		let { slotId: _, propertyId: v } = unwrapPropertyKeyOfCustomSlot(m), y = this.children[`${p}/${g}`];
-		if (!y) throw Error("sandbox not found");
-		if (!y.isValidOfCustomSlotProperty(_, v)) throw console.warn(`Sandbox/getMultipleCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
-		return y.customSlotProperties[v];
+		let { compId: _, slotId: v, propertyId: y } = unwrapPropertyKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotProperty(_, v, y)) throw console.warn(`Sandbox/getMultipleCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
+		let b = this.children[`${p}/${g}`];
+		if (!b) throw Error("sandbox not found");
+		return b.customSlotProperties[y];
 	}
 	async getCustomProperty(e, p) {
 		if (!this.isValidOfCustomProperty(p)) throw console.warn(`Sandbox/getCustomProperty invalid custom property id=${e}`), Error("invalid custom property");
@@ -10845,16 +10965,14 @@ var PromiseManager = class {
 	}
 	async getCustomAdaptSlotProperty(e, p) {
 		if (!this.parent) throw Error("not in slot");
-		let { slotId: m, propertyId: g } = unwrapPropertyKeyOfCustomSlot(p);
-		if (!this.isValidOfCustomSlotProperty(m, g)) throw console.warn(`Sandbox/getCustomAdaptSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
-		return this.customSlotProperties[g];
+		let { compId: m, slotId: g, propertyId: _ } = unwrapPropertyKeyOfCustomSlot(p);
+		if (!this.isValidOfCustomSlotProperty(m, g, _)) throw console.warn(`Sandbox/getCustomAdaptSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
+		return this.customSlotProperties[_];
 	}
 	async setProperty(e, p, m) {
 		let { kind: g, nodeId: v, propertyKey: y } = unwrapPropertyId(e), b = this.getNode(v);
 		if (!b) throw Error("node not found");
 		if (p = cloneDeep_default(p), g === "elementProperty") await this.setElementProperty(e, p, y, b);
-		else if (g === "elementSlotProperty") await this.setElementSlotProperty(e, p, v, y);
-		else if (g === "multipleElementSlotProperty") await this.setMultipleElementSlotProperty(e, p, v, y, m);
 		else if (g === "refProperty") await this.setRefProperty(e, p, v, y);
 		else if (g === "multipleRefProperty") await this.setMultipleRefProperty(e, p, v, y, m);
 		else if (g === "customSlotProperty") await this.setCustomSlotProperty(e, p, v, y);
@@ -10870,25 +10988,6 @@ var PromiseManager = class {
 		let v = getField(_, m);
 		isEqual_default(p, v) || (setField(_, m, p), this.hooks.onPropertyChange(e, p, v));
 	}
-	async setElementSlotProperty(e, p, m, _) {
-		let { elementKey: v, slotKey: y, propertyKey: b } = unwrapPropertyKeyOfElementSlot(_), x = this.children[`${m}/${y}`];
-		if (!x) throw Error("sandbox not found");
-		if (!x.isValidOfElementSlotProperty(v, y, b)) throw console.warn(`Sandbox/setElementSlotProperty invalid element slot property id=${e}`), Error("invalid element slot property");
-		let S = { value: void 0 };
-		x.eventBus.emit(`property/${b}/get`, { result: S });
-		let C = S.value;
-		isEqual_default(p, C) || x.eventBus.emit(`property/${b}/set`, p);
-	}
-	async setMultipleElementSlotProperty(e, p, m, _, v) {
-		if (!v) throw Error("instance not available");
-		let { elementKey: y, slotKey: b, propertyKey: x } = unwrapPropertyKeyOfElementSlot(_), S = this.children[`${m}/${b}/${v}`];
-		if (!S) throw Error("sandbox not found");
-		if (!S.isValidOfElementSlotProperty(y, b, x)) throw console.warn(`Sandbox/setMultipleElementSlotProperty invalid element slot property id=${e}`), Error("invalid element slot property");
-		let C = { value: void 0 };
-		S.eventBus.emit(`property/${x}/get`, { result: C });
-		let w = C.value;
-		isEqual_default(p, w) || S.eventBus.emit(`property/${x}/set`, p);
-	}
 	async setRefProperty(e, p, m, _) {
 		let v = this.children[m];
 		if (!v) throw Error("sandbox not found");
@@ -10905,19 +11004,21 @@ var PromiseManager = class {
 		isEqual_default(p, b) || (y.customProperties[_] = p, y.hooks.onPropertyChange(makePropertyId("customProperty", "globality", _), p, b, v), this.hooks.onPropertyChange(e, p, b, v));
 	}
 	async setCustomSlotProperty(e, p, m, _) {
-		let { slotId: v, propertyId: y } = unwrapPropertyKeyOfCustomSlot(_), b = this.children[m];
-		if (!b) throw Error("sandbox not found");
-		if (!b.isValidOfCustomSlotProperty(v, y)) throw console.warn(`Sandbox/setCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
-		let x = b.customSlotProperties[y];
-		isEqual_default(p, x) || (b.customSlotProperties[y] = p, b.hooks.onPropertyChange(makePropertyId("customAdaptSlotProperty", "globality", _), p, x), this.hooks.onPropertyChange(e, p, x));
+		let { compId: v, slotId: y, propertyId: b } = unwrapPropertyKeyOfCustomSlot(_);
+		if (!this.isValidOfCustomSlotProperty(v, y, b)) throw console.warn(`Sandbox/setCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
+		let x = this.children[m];
+		if (!x) throw Error("sandbox not found");
+		let S = x.customSlotProperties[b];
+		isEqual_default(p, S) || (x.customSlotProperties[b] = p, x.hooks.onPropertyChange(makePropertyId("customAdaptSlotProperty", "globality", _), p, S), this.hooks.onPropertyChange(e, p, S));
 	}
 	async setMultipleCustomSlotProperty(e, p, m, _, v) {
 		if (!v) throw Error("instance not available");
-		let { slotId: y, propertyId: b } = unwrapPropertyKeyOfCustomSlot(_), x = this.children[`${m}/${v}`];
-		if (!x) throw Error("sandbox not found");
-		if (!x.isValidOfCustomSlotProperty(y, b)) throw console.warn(`Sandbox/setMultipleCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
-		let S = x.customSlotProperties[b];
-		isEqual_default(p, S) || (x.customSlotProperties[b] = p, x.hooks.onPropertyChange(makePropertyId("customAdaptSlotProperty", "globality", _), p, S, v), this.hooks.onPropertyChange(e, p, S, v));
+		let { compId: y, slotId: b, propertyId: x } = unwrapPropertyKeyOfCustomSlot(_);
+		if (!this.isValidOfCustomSlotProperty(y, b, x)) throw console.warn(`Sandbox/setMultipleCustomSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
+		let S = this.children[`${m}/${v}`];
+		if (!S) throw Error("sandbox not found");
+		let C = S.customSlotProperties[x];
+		isEqual_default(p, C) || (S.customSlotProperties[x] = p, S.hooks.onPropertyChange(makePropertyId("customAdaptSlotProperty", "globality", _), p, C, v), this.hooks.onPropertyChange(e, p, C, v));
 	}
 	async setCustomProperty(e, p, m) {
 		if (!this.isValidOfCustomProperty(m)) throw console.warn(`Sandbox/setCustomProperty invalid custom property id=${e}`), Error("invalid custom property");
@@ -10935,10 +11036,10 @@ var PromiseManager = class {
 	}
 	async setCustomAdaptSlotProperty(e, p, m) {
 		if (!this.parent) throw Error("not in slot");
-		let { slotId: _, propertyId: v } = unwrapPropertyKeyOfCustomSlot(m);
-		if (!this.isValidOfCustomSlotProperty(_, v)) throw console.warn(`Sandbox/setCustomAdaptSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
-		let y = this.customSlotProperties[v];
-		isEqual_default(p, y) || (this.customSlotProperties[v] = p, this.hooks.onPropertyChange(e, p, y), this.kind === "customSlot" ? this.parent.hooks.onPropertyChange(makePropertyId("customSlotProperty", this.nodeId, m), p, y) : this.kind === "multipleCustomSlot" && this.parent.hooks.onPropertyChange(makePropertyId("multipleCustomSlotProperty", this.nodeId, m), p, y, this.instance));
+		let { compId: _, slotId: v, propertyId: y } = unwrapPropertyKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotProperty(_, v, y)) throw console.warn(`Sandbox/setCustomAdaptSlotProperty invalid custom slot property id=${e}`), Error("invalid custom slot property");
+		let b = this.customSlotProperties[y];
+		isEqual_default(p, b) || (this.customSlotProperties[y] = p, this.hooks.onPropertyChange(e, p, b), this.kind === "customSlot" ? this.parent.hooks.onPropertyChange(makePropertyId("customSlotProperty", this.nodeId, m), p, b) : this.kind === "multipleCustomSlot" && this.parent.hooks.onPropertyChange(makePropertyId("multipleCustomSlotProperty", this.nodeId, m), p, b, this.instance));
 	}
 	isValidOfElementMethod(e, p) {
 		let m = getElement(e);
@@ -10953,23 +11054,22 @@ var PromiseManager = class {
 	isValidOfCustomMethod(e) {
 		return this.meta.value ? !!this.meta.value.methods?.find((p) => p.id === e) : !1;
 	}
-	isValidOfCustomSlotMethod(e, p) {
-		if (!this.meta.value) return !1;
-		let m = this.meta.value.slots?.find((p) => p.id === e);
-		return !m || !m.methods ? !1 : !!m.methods.find((e) => e.id === p);
+	isValidOfCustomSlotMethod(e, p, m) {
+		let g = this.depends.value?.[e];
+		if (!g) return !1;
+		let _ = g.meta.slots?.find((e) => e.id === p);
+		return !_ || !_.methods ? !1 : !!_.methods.find((e) => e.id === m);
 	}
 	async callMethod(e, p, m) {
 		this.debugTrace(makeFuncInfo("callMethod", e, p, m));
 		let { kind: g, nodeId: _, methodKey: v } = unwrapMethodId(e), y = this.getNode(_);
 		if (!y) throw Error("node not found");
-		if (g === "elementMethod") await this.callElementMethod(e, m, y.basic.key, v);
-		else if (g === "elementSlotMethod") await this.callElementSlotMethod(e, m, _, v);
-		else if (g === "multipeElementSlotMethod") await this.callMultipleElementSlotMethod(e, p, m, _, v);
-		else if (g === "refMethod") await this.callRefMethod(e, m, _, v);
-		else if (g === "multipleRefMethod") await this.callMultipleRefMethod(e, p, m, _, v);
-		else if (g === "elementAdaptSlotMethod") await this.callElementAdaptSlotMethod(e, m, v);
-		else if (g === "customAdaptSlotMethod") await this.callCustomAdaptSlotMethod(e, m, v);
-		else throw Error("not implemented method kind");
+		if (g === "elementMethod") return await this.callElementMethod(e, m, y.basic.key, v);
+		if (g === "refMethod") return await this.callRefMethod(e, m, _, v);
+		if (g === "multipleRefMethod") return await this.callMultipleRefMethod(e, p, m, _, v);
+		if (g === "elementAdaptSlotMethod") return await this.callElementAdaptSlotMethod(e, m, v);
+		if (g === "customAdaptSlotMethod") return await this.callCustomAdaptSlotMethod(e, m, v);
+		throw Error("not implemented method kind");
 	}
 	async callElementMethod(e, p, m, g) {
 		if (!this.isValidOfElementMethod(m, g)) throw console.log(`Sandbox/callElementMethod invalid element method id=${e}`), Error("invalid element method");
@@ -10980,27 +11080,6 @@ var PromiseManager = class {
 			outputs: _
 		}), _;
 	}
-	async callElementSlotMethod(e, p, m, g) {
-		let { elementKey: _, slotKey: v, methodKey: y } = unwrapMethodKeyOfElementSlot(g), b = this.children[`${m}/${v}`];
-		if (!b) throw Error("sandbox not found");
-		if (!b.isValidOfElementSlotMethod(_, v, y)) throw console.warn(`Sandbox/callElementSlotMethod invalid element slot method id=${e}`), Error("invalid element slot method");
-		let x = {};
-		return b.eventBus.emit(`method/${y}`, {
-			inputs: p,
-			outputs: x
-		}), x;
-	}
-	async callMultipleElementSlotMethod(e, p, m, g, _) {
-		if (!p) throw Error("instance not available");
-		let { elementKey: v, slotKey: y, methodKey: b } = unwrapMethodKeyOfElementSlot(_), x = this.children[`${g}/${y}/${p}`];
-		if (!x) throw Error("sandbox not found");
-		if (!x.isValidOfElementSlotMethod(v, y, b)) throw console.warn(`Sandbox/callMultipleElementSlotMethod invalid element slot method id=${e}`), Error("invalid element slot method");
-		let S = {};
-		return x.eventBus.emit(`method/${b}`, {
-			inputs: m,
-			outputs: S
-		}), S;
-	}
 	async callRefMethod(e, p, m, g) {
 		let _ = this.children[m];
 		if (!_) throw Error("sandbox not found");
@@ -11019,15 +11098,16 @@ var PromiseManager = class {
 		let { elementKey: g, slotKey: _, methodKey: v } = unwrapMethodKeyOfElementSlot(m);
 		if (!this.isValidOfElementSlotMethod(g, _, v)) throw console.warn(`Sandbox/callElementAdaptSlotMethod invalid element slot method id=${e}`), Error("invalid element slot method");
 		let y = {};
-		return this.eventBus.emit(`method/${_}/${v}`, {
+		return this.eventBus.emit(`method/${v}`, {
+			instance: this.instance,
 			inputs: p,
 			outputs: y
 		}), y;
 	}
 	async callCustomAdaptSlotMethod(e, p, m) {
 		if (!this.parent) throw Error("not in slot");
-		let { slotId: g, methodId: _ } = unwrapMethodKeyOfCustomSlot(m);
-		if (!this.isValidOfCustomSlotMethod(g, _)) throw console.warn(`Sandbox/callCustomAdaptSlotMethod invalid custom slot method id=${e}`), Error("invalid custom slot method");
+		let { compId: g, slotId: _, methodId: v } = unwrapMethodKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotMethod(g, _, v)) throw console.warn(`Sandbox/callCustomAdaptSlotMethod invalid custom slot method id=${e}`), Error("invalid custom slot method");
 		if (this.kind === "customSlot") return await this.parent.callFunctionAsync(getImplementMethodName("customSlotMethod", this.nodeId, m), "", p);
 		if (this.kind === "multipleCustomSlot") return await this.parent.callFunctionAsync(getImplementMethodName("multipleCustomSlotMethod", this.nodeId, m), this.instance, p);
 		throw Error("unexpected sandbox kind");
@@ -11049,35 +11129,35 @@ var PromiseManager = class {
 	}
 };
 function useSandbox(e, p, m, _, v, y, b, x) {
-	let S = injectOrg(), C = injectEnv(), w = injectMode(), T = injectType(), E = injectDevice(), D = injectDark();
+	let S = injectOrg(), C = injectEnv(), w = injectMode(), T = injectType(), E = injectDevice(), D = injectDark(), O = injectDepends();
 	if (!isExecutableMode(w)) return { sandbox: void 0 };
-	let O = injectRuntime(), k = new Sandbox(e, p, m, _, v, S, C, w, T, {
-		onReady: j,
-		onDestroy: M,
-		onPropertyChange: N,
-		onStateChange: P
+	let k = injectRuntime(), A = new Sandbox(e, p, m, _, v, S, C, w, T, {
+		onReady: M,
+		onDestroy: N,
+		onPropertyChange: P,
+		onStateChange: F
 	});
-	provideSandbox(k), onUnmounted(() => {
-		k.dispose();
+	provideSandbox(A), onUnmounted(() => {
+		A.dispose();
 	});
-	let A = async () => {
-		k.destroyVm(), !(!y.value || !b.value) && (k.prepare(y, b, x), await k.createVm(O, b.value.code.script));
+	let j = async () => {
+		A.destroyVm(), !(!y.value || !b.value) && (A.prepare(y, b, O, x), await A.createVm(k, b.value.code.script));
 	};
-	A(), watch([y, b], () => {
-		A();
+	j(), watch([y, b], () => {
+		j();
 	});
-	async function j() {
-		await k.triggerEvent(makeEventId("elementEvent", "globality", "startup"), "");
+	async function M() {
+		await A.triggerEvent(makeEventId("elementEvent", "globality", "startup"), []);
 		let e = calcBreakpoint(E.value.width), p = calcBreakpoint(E.value.width);
-		await k.triggerEvent(makeEventId("elementEvent", "globality", "screenSizeChange"), "", e, p), await k.triggerEvent(makeEventId("elementEvent", "globality", "darkModeChange"), "", D.value);
+		await A.triggerEvent(makeEventId("elementEvent", "globality", "screenSizeChange"), [e, p]), await A.triggerEvent(makeEventId("elementEvent", "globality", "darkModeChange"), [D.value]);
 	}
-	async function M() {
-		k.callFunctionSync("__destroy__");
+	async function N() {
+		A.callFunctionSync("__destroy__");
 	}
-	async function N(e, p, m, _) {
-		if (!k.vm) return;
+	async function P(e, p, m, _) {
+		if (!A.vm) return;
 		let { kind: v, nodeId: y, propertyKey: x } = unwrapPropertyId(e);
-		if (await k.triggerEvent(makeEventId(`${v}ChangeEvent`, y, x), _ ?? "", p, m), b.value?.code.reactivity && triggerReactivity(k, b.value.code.reactivity, makeTriggerId("propertyTrigger", e), p, m), v === "elementProperty") {
+		if (await A.triggerEvent(makeEventId(`${v}ChangeEvent`, y, x), [p, m], _), b.value?.code.reactivity && triggerReactivity(A, b.value.code.reactivity, makeTriggerId("propertyTrigger", e), p, m), v === "elementProperty") {
 			if (isEqual_default(x, toDotString(["settings", "slot"]))) {
 				let e = b.value?.view.nodeLites.find((e) => e.id === y);
 				e ? e.slotId = p : console.assert(!1);
@@ -11088,16 +11168,16 @@ function useSandbox(e, p, m, _, v, y, b, x) {
 			}
 		}
 	}
-	async function P(e, p, m) {
-		k.vm && (await k.triggerEvent(makeEventId("stateChangeEvent", "globality", e), "", p, m), b.value?.code.reactivity && triggerReactivity(k, b.value.code.reactivity, makeTriggerId("stateTrigger", e), p, m));
+	async function F(e, p, m) {
+		A.vm && (await A.triggerEvent(makeEventId("stateChangeEvent", "globality", e), [p, m]), b.value?.code.reactivity && triggerReactivity(A, b.value.code.reactivity, makeTriggerId("stateTrigger", e), p, m));
 	}
 	return watch(E, async (e, p) => {
-		if (!k.vm) return;
+		if (!A.vm) return;
 		let m = calcBreakpoint(e.width), g = calcBreakpoint(p?.width ?? e.width);
-		await k.callFunctionAsync("__triggerEventV1__", makeEventId("elementEvent", "globality", "screenSizeChange"), "", m, g);
+		A.triggerEvent(makeEventId("elementEvent", "globality", "screenSizeChange"), [m, g]);
 	}), watch(D, async (e) => {
-		k.vm && await k.callFunctionAsync("__triggerEventV1__", makeEventId("elementEvent", "globality", "darkModeChange"), "", e);
-	}), { sandbox: k };
+		A.vm && A.triggerEvent(makeEventId("elementEvent", "globality", "darkModeChange"), [e]);
+	}), { sandbox: A };
 }
 function useTheme() {
 	let e = injectDark();

package/dist/sandbox/sandbox/index.d.ts

@@ -1,6 +1,6 @@
 import { QuickJSContext, QuickJSRuntime } from 'quickjs-emscripten';
-import { Ref } from 'vue';
-import { Data, Env, Meta, Mode, Node, SandboxKind } from '@/types';
+import { Ref, ShallowRef } from 'vue';
+import { Data, Depends, Env, Meta, Mode, Node, SandboxKind } from '@/types';
 import { InitValues, Inputs } from '../common';
 import { Hooks } from './hooks';
 import { PromiseManager } from './promiseManager';
@@ -28,7 +28,8 @@ export declare class Sandbox {
     private removeChild;
     private meta;
     private data;
-    prepare(meta: Ref<Meta | undefined>, data: Ref<Data | undefined>, initValues?: InitValues): void;
+    private depends;
+    prepare(meta: Ref<Meta | undefined>, data: Ref<Data | undefined>, depends: ShallowRef<Depends | undefined>, initValues?: InitValues): void;
     getNode(nodeId: string): Node | undefined;
     createVm(runtime: QuickJSRuntime, code: string): Promise<void>;
     destroyVm(): void;
@@ -39,8 +40,29 @@ export declare class Sandbox {
     isValidOfElementEvent(elementKey: string, eventKey: string): boolean;
     isValidOfElementSlotEvent(elementKey: string, slotKey: string, eventKey: string): boolean;
     isValidOfCustomEvent(eventId: string): boolean;
-    isValidOfCustomSlotEvent(slotId: string, eventId: string): boolean;
-    triggerEvent(id: string, instance: string, ...params: any[]): Promise<void>;
+    isValidOfCustomSlotEvent(compId: string, slotId: string, eventId: string): boolean;
+    triggerEvent(id: string, params: any[], instance?: string): Promise<void>;
+    private triggerElementEvent;
+    private triggerElementPropertyChangeEvent;
+    private triggerElementSlotEvent;
+    private triggerElementSlotPropertyChangeEvent;
+    private triggerMultipleElementSlotEvent;
+    private triggerMultipleElementSlotPropertyChangeEvent;
+    private triggerRefEvent;
+    private triggerRefPropertyChangeEvent;
+    private triggerMultipleRefEvent;
+    private triggerMultipleRefPropertyChangeEvent;
+    private triggerCustomSlotEvent;
+    private triggerCustomSlotPropertyChangeEvent;
+    private triggerMultipleCustomSlotEvent;
+    private triggerMultipleCustomSlotPropertyChangeEvent;
+    private triggerCustomEvent;
+    private triggerCustomPropertyChangeEvent;
+    private triggerElementAdaptSlotEvent;
+    private triggerElementAdaptSlotPropertyChangeEvent;
+    private triggerCustomAdaptSlotEvent;
+    private triggerCustomAdaptSlotPropertyChangeEvent;
+    private triggerStateChangeEvent;
     customProperties: {
         [key: string]: any;
     };
@@ -51,11 +73,9 @@ export declare class Sandbox {
     isValidOfElementProperty(elementKey: string, propertyKey: string): boolean;
     isValidOfElementSlotProperty(elementKey: string, slotKey: string, propertyKey: string): boolean;
     isValidOfCustomProperty(propertyId: string): boolean;
-    isValidOfCustomSlotProperty(slotId: string, propertyId: string): boolean;
+    isValidOfCustomSlotProperty(compId: string, slotId: string, propertyId: string): boolean;
     getProperty(id: string, instance?: string): Promise<any>;
     private getElementProperty;
-    private getElementSlotProperty;
-    private getMultipleElementSlotProperty;
     private getRefProperty;
     private getMultipleRefProperty;
     private getCustomSlotProperty;
@@ -65,8 +85,6 @@ export declare class Sandbox {
     private getCustomAdaptSlotProperty;
     setProperty(id: string, newValue: any, instance?: string): Promise<void>;
     private setElementProperty;
-    private setElementSlotProperty;
-    private setMultipleElementSlotProperty;
     private setRefProperty;
     private setMultipleRefProperty;
     private setCustomSlotProperty;
@@ -77,11 +95,9 @@ export declare class Sandbox {
     isValidOfElementMethod(elementKey: string, methodKey: string): boolean;
     isValidOfElementSlotMethod(elementKey: string, slotKey: string, methodKey: string): boolean;
     isValidOfCustomMethod(methodId: string): boolean;
-    isValidOfCustomSlotMethod(slotId: string, methodId: string): boolean;
-    callMethod(id: string, instance: string, inputs: Inputs): Promise<void>;
+    isValidOfCustomSlotMethod(compId: string, slotId: string, methodId: string): boolean;
+    callMethod(id: string, instance: string, inputs: Inputs): Promise<any>;
     private callElementMethod;
-    private callElementSlotMethod;
-    private callMultipleElementSlotMethod;
     private callRefMethod;
     private callMultipleRefMethod;
     private callElementAdaptSlotMethod;

package/dist/sandbox/sandbox/initCode.d.ts

@@ -1 +1 @@
-export declare const initCode = "\nlet __events__ = {}\n\nfunction __onEventV1__(id, callback) {\n  if (typeof(id) !== 'string' || !id) {\n    return\n  }\n  if (typeof(callback) !== 'function') {\n    return\n  }\n  if (!__events__[id]) {\n    __events__[id] = []\n  }\n  const callbacks = __events__[id]\n  for (let i = 0; i < callbacks.length; i++) {\n    if (callbacks[i] === callback) {\n      return\n    }\n  }\n  callbacks.push(callback)\n}\n\nasync function __triggerEventInner__(id, ...params) {\n  if (typeof(id) !== 'string' || !id) {\n    return\n  }\n  if (!__events__[id]) {\n    return\n  }\n  const callbacks = __events__[id]\n  if (!callbacks) {\n    return\n  }\n  for (let i = 0; i < callbacks.length; i++) {\n    await callbacks[i](...params)\n  }\n}\n\nlet __timers__ = {}\nlet __currTimerId__ = 0\n\nfunction __createTimerV1__(interval, loop, count, immediate, callback) {\n  if (!loop && count <= 0) {\n    return\n  }\n  const timer = {}\n  timer.id = __currTimerId__++\n  timer.interval = interval\n  timer.loop = loop\n  timer.count = count\n  timer.immediate = immediate\n  timer.callback = callback\n  __timers__[timer.id] = timer\n  if (timer.immediate) {\n    __timeoutCallbackV1__(timer.id)\n  } else {\n    __timeoutV1__(timer.id, timer.interval)\n  }\n}\n\nasync function __timeoutCallback__(timerId) {\n  const timer = __timers__[timerId]\n  if (timer) {\n    timer.callback()\n    // \u4FEE\u6539\u8BA1\u6570\n    if (!timer.loop) {\n      timer.count = timer.count - 1\n    }\n    // \u89E6\u53D1\u8D85\u65F6\n    if (timer.loop || timer.count > 0) {\n      await __timeoutV1__(timer.id, timer.interval)\n    }\n    // \u56DE\u6536\n    if (!timer.loop && timer.count <= 0) {\n      delete __timers__[timer.id]\n    }\n  }\n}\n\nfunction __destroy__() {\n  __events__ = {}\n  __timers__ = {}\n}\n";
+export declare const initCode = "\nlet __events__ = {}\n\nfunction __onEventV1__(id, callback) {\n  if (typeof(id) !== 'string' || !id) {\n    return\n  }\n  if (typeof(callback) !== 'function') {\n    return\n  }\n  if (!__events__[id]) {\n    __events__[id] = []\n  }\n  const callbacks = __events__[id]\n  for (let i = 0; i < callbacks.length; i++) {\n    if (callbacks[i] === callback) {\n      return\n    }\n  }\n  callbacks.push(callback)\n}\n\nasync function __triggerEventInner__(id, params, instance) {\n  if (!__events__[id]) {\n    return\n  }\n  const callbacks = __events__[id]\n  if (!callbacks) {\n    return\n  }\n  for (let i = 0; i < callbacks.length; i++) {\n    await callbacks[i](params, instance)\n  }\n}\n\nlet __timers__ = {}\nlet __currTimerId__ = 0\n\nfunction __createTimerV1__(interval, loop, count, immediate, callback) {\n  if (!loop && count <= 0) {\n    return\n  }\n  const timer = {}\n  timer.id = __currTimerId__++\n  timer.interval = interval\n  timer.loop = loop\n  timer.count = count\n  timer.immediate = immediate\n  timer.callback = callback\n  __timers__[timer.id] = timer\n  if (timer.immediate) {\n    __timeoutCallbackV1__(timer.id)\n  } else {\n    __timeoutV1__(timer.id, timer.interval)\n  }\n}\n\nasync function __timeoutCallback__(timerId) {\n  const timer = __timers__[timerId]\n  if (timer) {\n    timer.callback()\n    // \u4FEE\u6539\u8BA1\u6570\n    if (!timer.loop) {\n      timer.count = timer.count - 1\n    }\n    // \u89E6\u53D1\u8D85\u65F6\n    if (timer.loop || timer.count > 0) {\n      await __timeoutV1__(timer.id, timer.interval)\n    }\n    // \u56DE\u6536\n    if (!timer.loop && timer.count <= 0) {\n      delete __timers__[timer.id]\n    }\n  }\n}\n\nfunction __destroy__() {\n  __events__ = {}\n  __timers__ = {}\n}\n";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "x-runtime-lib",
   "private": false,
-  "version": "0.8.198",
+  "version": "0.8.200",
   "type": "module",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,8 +33,7 @@
     "three": "^0.182.0",
     "vue": "^3.5.27",
     "vue-i18n": "^11.2.8",
-    "vuetify": "^3.11.7",
-    "x-block-lib": "link:../x-block-lib"
+    "vuetify": "^3.11.7"
   },
   "peerDependencies": {
     "x-error-lib": "^0.5.13",