x-runtime-lib 0.8.203 → 0.8.205

package/dist/index.js

@@ -10437,6 +10437,28 @@ function _usingCtx() {
 		}
 	};
 }
+const errors = {
+	functionNotAvailable: /* @__PURE__ */ Error("func not available"),
+	instanceNotAvailable: /* @__PURE__ */ Error("instance not available"),
+	invalidCustomEvent: /* @__PURE__ */ Error("invalid custom event"),
+	invalidCustomMethod: /* @__PURE__ */ Error("invalid custom method"),
+	invalidCustomProperty: /* @__PURE__ */ Error("invalid custom property"),
+	invalidCustomSlotEvent: /* @__PURE__ */ Error("invalid custom slot event"),
+	invalidCustomSlotMethod: /* @__PURE__ */ Error("inavlid custom slot method"),
+	invalidCustomSlotProperty: /* @__PURE__ */ Error("invalid custom slot property"),
+	invalidElementEvent: /* @__PURE__ */ Error("invalid element event"),
+	invalidElementMethod: /* @__PURE__ */ Error("invaild element method"),
+	invalidElementProperty: /* @__PURE__ */ Error("invalid element property"),
+	invalidElementSlotEvent: /* @__PURE__ */ Error("invalid element slot event"),
+	invalidElementSlotMethod: /* @__PURE__ */ Error("invalid element slot method"),
+	invalidElementSlotProperty: /* @__PURE__ */ Error("invalid element slot property"),
+	invalidState: /* @__PURE__ */ Error("invalid state"),
+	nodeNotFound: /* @__PURE__ */ Error("node not found"),
+	notInSlot: /* @__PURE__ */ Error("not in slot"),
+	sandboxNotFound: /* @__PURE__ */ Error("sandbox not found"),
+	slotIncompatible: /* @__PURE__ */ Error("slot incompatible"),
+	vmNotAvailable: /* @__PURE__ */ Error("vm not available")
+};
 function newAny(e, p) {
 	if (p === void 0) return e.undefined;
 	if (p === null) return e.null;
@@ -10682,9 +10704,6 @@ var PromiseManager = class {
 	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, 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), this.data.value?.code.reactivity && await initReactivity(this, this.data.value?.code.reactivity), await nextTick(), this.hooks.onReady();
 	}
@@ -10693,22 +10712,22 @@ var PromiseManager = class {
 	}
 	setGlobalVariable(e, p) {
 		let { vm: m } = this;
-		if (!m) throw Error("vm not available");
+		if (!m) throw errors.vmNotAvailable;
 		m.setProp(m.global, e, newAny(m, p));
 	}
 	getGlobalVariable(e) {
 		let { vm: p } = this;
-		if (!p) throw Error("vm not available");
+		if (!p) throw errors.vmNotAvailable;
 		return p.getProp(p.global, e).consume((e) => p.dump(e));
 	}
 	callFunctionSync(e, ...p) {
 		try {
 			var m = _usingCtx();
 			let { vm: g } = this;
-			if (!g) throw Error("vm not available");
+			if (!g) throw errors.vmNotAvailable;
 			noTraceCallFuncs.includes(e) || this.debugTrace(makeFuncInfo(e, ...p));
 			let _ = m.u(g.getProp(g.global, e));
-			if (g.typeof(_) !== "function") throw Error(`function<${e}> not available`);
+			if (g.typeof(_) !== "function") throw errors.functionNotAvailable;
 			let v = p.map((e) => newAny(g, e)), y = g.unwrapResult(g.callFunction(_, g.undefined, ...v)).consume((e) => g.dump(e));
 			return v.forEach((e) => e.dispose()), y;
 		} catch (e) {
@@ -10721,10 +10740,10 @@ var PromiseManager = class {
 		try {
 			var m = _usingCtx();
 			let { vm: g } = this;
-			if (!g) throw Error("vm not available");
+			if (!g) throw errors.vmNotAvailable;
 			noTraceCallFuncs.includes(e) || this.debugTrace(makeFuncInfo(e, ...p));
 			let _ = m.u(g.getProp(g.global, e));
-			if (g.typeof(_) !== "function") throw Error(`function<${e}> not available`);
+			if (g.typeof(_) !== "function") throw errors.functionNotAvailable;
 			let v = p.map((e) => newAny(g, e)), y = g.unwrapResult(g.callFunction(_, g.undefined, ...v)).consume((e) => g.resolvePromise(e));
 			return g.runtime.executePendingJobs(), v.map((e) => e.dispose()), g.unwrapResult(await y).consume((e) => g.dump(e));
 		} catch (e) {
@@ -10733,173 +10752,24 @@ var PromiseManager = class {
 			m.d();
 		}
 	}
-	isValidOfElementEvent(e, p) {
-		let m = getElement(e);
-		return !m || !m.events ? !1 : !!m.events.find((e) => e.key === p);
-	}
-	isValidOfElementSlotEvent(e, p, m) {
-		let g = getElement(e);
-		if (!g || !g.slots) return !1;
-		let _ = g.slots.find((e) => e.key === p);
-		return !_ || !_.events ? !1 : !!_.events.find((e) => e.key === m);
-	}
-	isValidOfCustomEvent(e) {
-		return this.meta.value ? !!this.meta.value.events?.find((p) => p.id === e) : !1;
+	getNode(e) {
+		return this.data.value?.view.nodes[e];
 	}
-	isValidOfCustomSlotEvent(e, p, m) {
-		let g = this.depends.value?.[e];
+	isEqualOfElementSlot(e, p) {
+		let m = this.getNode("globality");
+		if (!m) return !1;
+		let g = m.settings?.adaptSlot;
 		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);
+		let { kind: _, mainKey: v, slotKey: y } = unwrapSlotId(g);
+		return !(_ !== "elementSlot" && _ !== "multipleElementSlot" || e !== v || p !== y);
 	}
-	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 && (this.instance ? await this.parent.triggerEvent(makeEventId("multipleRefEvent", this.nodeId, m), p, this.instance) : await this.parent.triggerEvent(makeEventId("refEvent", this.nodeId, m), p));
-	}
-	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);
+	isEqualOfCustomSlot(e, p) {
+		let m = this.getNode("globality");
+		if (!m) return !1;
+		let g = m.settings?.adaptSlot;
+		if (!g) return !1;
+		let { kind: _, mainKey: v, slotKey: y } = unwrapSlotId(g);
+		return !(_ !== "customSlot" && _ !== "multipleCustomSlot" || e !== v || p !== y);
 	}
 	customProperties = {};
 	customSlotProperties = {};
@@ -10932,7 +10802,7 @@ var PromiseManager = class {
 	}
 	async getProperty(e, p) {
 		let { kind: m, nodeId: g, propertyKey: _ } = unwrapPropertyId(e), v = this.getNode(g);
-		if (!v) throw Error("node not found");
+		if (!v) throw errors.nodeNotFound;
 		if (m === "elementProperty") return await this.getElementProperty(e, v, _);
 		if (m === "refProperty") return await this.getRefProperty(e, g, _);
 		if (m === "multipleRefProperty") return await this.getMultipleRefProperty(e, g, _, p);
@@ -10941,126 +10811,121 @@ var PromiseManager = class {
 		if (m === "customProperty") return await this.getCustomProperty(e, _);
 		if (m === "elementAdaptSlotProperty") return await this.getElementAdaptSlotProperty(e, _);
 		if (m === "customAdaptSlotProperty") return await this.getCustomAdaptSlotProperty(e, _);
-		throw Error("not implemented property kind");
+		console.assert(!1);
 	}
 	async getElementProperty(e, p, m) {
-		if (!this.isValidOfElementProperty(p.basic.key, m)) throw console.warn(`Sandbox/getElementProperty invalid element property id=${e}`), Error("invalid element property");
+		if (!this.isValidOfElementProperty(p.basic.key, m)) throw console.warn(`Sandbox/getElementProperty invalid element property id=${e}`), errors.invalidElementProperty;
 		return getField(p, m);
 	}
 	async getRefProperty(e, p, m) {
 		let g = this.children[p];
-		if (!g) throw Error("sandbox not found");
-		if (!g.isValidOfCustomProperty(m)) throw console.warn(`Sandbox/getRefProperty invalid custom property id=${e}`), Error("invalid custom property");
+		if (!g) throw errors.sandboxNotFound;
+		if (!g.isValidOfCustomProperty(m)) throw console.warn(`Sandbox/getRefProperty invalid custom property id=${e}`), errors.invalidCustomProperty;
 		return g.customProperties[m];
 	}
 	async getMultipleRefProperty(e, p, m, g) {
-		if (!g) throw Error("instance not available");
+		if (!g) throw errors.instanceNotAvailable;
 		let _ = this.children[`${p}/${g}`];
-		if (!_) throw Error("sandbox not found");
-		if (!_.isValidOfCustomProperty(m)) throw console.warn(`Sandbox/getMultipleRefProperty invalid custom property id=${e}`), Error("invalid custom property");
+		if (!_) throw errors.sandboxNotFound;
+		if (!_.isValidOfCustomProperty(m)) throw console.warn(`Sandbox/getMultipleRefProperty invalid custom property id=${e}`), errors.invalidCustomProperty;
 		return _.customProperties[m];
 	}
 	async getCustomSlotProperty(e, p, m) {
 		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");
+		if (!this.isValidOfCustomSlotProperty(g, _, v)) throw console.warn(`Sandbox/getCustomSlotProperty invalid custom slot property id=${e}`), errors.invalidCustomSlotProperty;
 		let y = this.children[p];
-		if (!y) throw Error("sandbox not found");
+		if (!y) throw errors.sandboxNotFound;
 		return y.customSlotProperties[v];
 	}
 	async getMultipleCustomSlotProperty(e, p, m, g) {
-		if (!g) throw Error("instance not available");
+		if (!g) throw errors.instanceNotAvailable;
 		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");
+		if (!this.isValidOfCustomSlotProperty(_, v, y)) throw console.warn(`Sandbox/getMultipleCustomSlotProperty invalid custom slot property id=${e}`), errors.invalidCustomSlotProperty;
 		let b = this.children[`${p}/${g}`];
-		if (!b) throw Error("sandbox not found");
+		if (!b) throw errors.sandboxNotFound;
 		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");
+		if (!this.isValidOfCustomProperty(p)) throw console.warn(`Sandbox/getCustomProperty invalid custom property id=${e}`), errors.invalidCustomProperty;
 		return this.customProperties[p];
 	}
 	async getElementAdaptSlotProperty(e, p) {
-		if (!this.parent) throw Error("not in slot");
+		if (!this.parent) throw errors.notInSlot;
 		let { elementKey: m, slotKey: g, propertyKey: _ } = unwrapPropertyKeyOfElementSlot(p);
-		if (!this.isValidOfElementSlotProperty(m, g, _)) throw console.warn(`Sandbox/getElementAdaptSlotProperty invalid element slot property id=${e}`), Error("invalid element slot property");
+		if (!this.isEqualOfElementSlot(m, g)) throw errors.slotIncompatible;
+		if (!this.isValidOfElementSlotProperty(m, g, _)) throw console.warn(`Sandbox/getElementAdaptSlotProperty invalid element slot property id=${e}`), errors.invalidElementSlotProperty;
 		let v = { value: void 0 };
-		return this.eventBus.emit(`property/${g}/${_}/get`, { result: v }), v.value;
+		return this.eventBus.emit(`property/${_}/get`, { result: v }), v.value;
 	}
 	async getCustomAdaptSlotProperty(e, p) {
-		if (!this.parent) throw Error("not in slot");
+		if (!this.parent) throw errors.notInSlot;
 		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");
+		if (!this.isEqualOfCustomSlot(m, g)) throw errors.slotIncompatible;
+		if (!this.isValidOfCustomSlotProperty(m, g, _)) throw console.warn(`Sandbox/getCustomAdaptSlotProperty invalid custom slot property id=${e}`), errors.invalidCustomSlotProperty;
 		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 === "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);
-		else if (g === "multipleCustomSlotProperty") await this.setMultipleCustomSlotProperty(e, p, v, y, m);
-		else if (g === "customProperty") await this.setCustomProperty(e, p, y);
-		else if (g === "elementAdaptSlotProperty") await this.setElementAdaptSlotProperty(e, p, y);
-		else if (g === "customAdaptSlotProperty") await this.setCustomAdaptSlotProperty(e, p, y);
-		else throw Error("not implemented property kind");
-		await nextTick();
+		if (!b) throw errors.nodeNotFound;
+		p = cloneDeep_default(p), g === "elementProperty" ? await this.setElementProperty(e, p, y, b) : g === "refProperty" ? await this.setRefProperty(e, p, v, y) : g === "multipleRefProperty" ? await this.setMultipleRefProperty(e, p, v, y, m) : g === "customSlotProperty" ? await this.setCustomSlotProperty(e, p, v, y) : g === "multipleCustomSlotProperty" ? await this.setMultipleCustomSlotProperty(e, p, v, y, m) : g === "customProperty" ? await this.setCustomProperty(e, p, y) : g === "elementAdaptSlotProperty" ? await this.setElementAdaptSlotProperty(e, p, y) : g === "customAdaptSlotProperty" ? await this.setCustomAdaptSlotProperty(e, p, y) : console.assert(!1), await nextTick();
 	}
 	async setElementProperty(e, p, m, _) {
-		if (!this.isValidOfElementProperty(_.basic.key, m)) throw console.warn(`Sandbox/setElementProperty invalid element property id=${e}`), Error("invalid element property");
+		if (!this.isValidOfElementProperty(_.basic.key, m)) throw console.warn(`Sandbox/setElementProperty invalid element property id=${e}`), errors.invalidElementProperty;
 		let v = getField(_, m);
 		isEqual_default(p, v) || (setField(_, m, p), this.hooks.onPropertyChange(e, p, v));
 	}
 	async setRefProperty(e, p, m, _) {
 		let v = this.children[m];
-		if (!v) throw Error("sandbox not found");
-		if (!v.isValidOfCustomProperty(_)) throw console.warn(`Sandbox/setRefProperty invalid custom property id=${e}`), Error("invalid custom property");
+		if (!v) throw errors.sandboxNotFound;
+		if (!v.isValidOfCustomProperty(_)) throw console.warn(`Sandbox/setRefProperty invalid custom property id=${e}`), errors.invalidCustomProperty;
 		let y = v.customProperties[_];
 		isEqual_default(p, y) || (v.customProperties[_] = p, v.hooks.onPropertyChange(makePropertyId("customProperty", "globality", _), p, y), this.hooks.onPropertyChange(e, p, y));
 	}
 	async setMultipleRefProperty(e, p, m, _, v) {
-		if (!v) throw Error("instance not available");
+		if (!v) throw errors.instanceNotAvailable;
 		let y = this.children[`${m}/${v}`];
-		if (!y) throw Error("sandbox not found");
-		if (!y.isValidOfCustomProperty(_)) throw console.warn(`Sandbox/setMultipleRefProperty invalid custom property id=${e}`), Error("invalid custom property");
+		if (!y) throw errors.sandboxNotFound;
+		if (!y.isValidOfCustomProperty(_)) throw console.warn(`Sandbox/setMultipleRefProperty invalid custom property id=${e}`), errors.invalidCustomProperty;
 		let b = y.customProperties[_];
 		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 { 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");
+		if (!this.isValidOfCustomSlotProperty(v, y, b)) throw console.warn(`Sandbox/setCustomSlotProperty invalid custom slot property id=${e}`), errors.invalidCustomSlotProperty;
 		let x = this.children[m];
-		if (!x) throw Error("sandbox not found");
+		if (!x) throw errors.sandboxNotFound;
 		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");
+		if (!v) throw errors.instanceNotAvailable;
 		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");
+		if (!this.isValidOfCustomSlotProperty(y, b, x)) throw console.warn(`Sandbox/setMultipleCustomSlotProperty invalid custom slot property id=${e}`), errors.invalidCustomSlotProperty;
 		let S = this.children[`${m}/${v}`];
-		if (!S) throw Error("sandbox not found");
+		if (!S) throw errors.sandboxNotFound;
 		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");
+		if (!this.isValidOfCustomProperty(m)) throw console.warn(`Sandbox/setCustomProperty invalid custom property id=${e}`), errors.invalidCustomProperty;
 		let _ = this.customProperties[m];
 		isEqual_default(p, _) || (this.customProperties[m] = p, this.hooks.onPropertyChange(e, p, _), this.parent && (this.instance ? this.parent.hooks.onPropertyChange(makePropertyId("multipleRefProperty", this.nodeId, m), p, _, this.instance) : this.parent.hooks.onPropertyChange(makePropertyId("refProperty", this.nodeId, m), p, _)));
 	}
 	async setElementAdaptSlotProperty(e, p, m) {
-		if (!this.parent) throw Error("not in slot");
+		if (!this.parent) throw errors.notInSlot;
 		let { elementKey: _, slotKey: v, propertyKey: y } = unwrapPropertyKeyOfElementSlot(m);
-		if (!this.isValidOfElementSlotProperty(_, v, y)) throw console.warn(`Sandbox/setElementAdaptSlotProperty invalid element slot property id=${e}`), Error("invalid element slot property");
+		if (!this.isEqualOfElementSlot(_, v)) throw errors.slotIncompatible;
+		if (!this.isValidOfElementSlotProperty(_, v, y)) throw console.warn(`Sandbox/setElementAdaptSlotProperty invalid element slot property id=${e}`), errors.invalidElementSlotProperty;
 		let b = { value: void 0 };
-		this.eventBus.emit(`property/${v}/${y}/get`, { result: b });
+		this.eventBus.emit(`property/${y}/get`, { result: b });
 		let x = b.value;
-		isEqual_default(p, x) || (this.eventBus.emit(`property/${v}/${y}/set`, p), this.hooks.onPropertyChange(e, p, x), this.kind === "elementSlot" ? this.parent.hooks.onPropertyChange(makePropertyId("elementSlotProperty", this.nodeId, m), p, x) : this.kind === "multipleElementSlot" && this.parent.hooks.onPropertyChange(makePropertyId("multipleElementSlotProperty", this.nodeId, m), p, x, this.instance));
+		isEqual_default(p, x) || (this.eventBus.emit(`property/${y}/set`, p), this.hooks.onPropertyChange(e, p, x), this.kind === "elementSlot" ? this.parent.hooks.onPropertyChange(makePropertyId("elementSlotProperty", this.nodeId, m), p, x) : this.kind === "multipleElementSlot" && this.parent.hooks.onPropertyChange(makePropertyId("multipleElementSlotProperty", this.nodeId, m), p, x, this.instance));
 	}
 	async setCustomAdaptSlotProperty(e, p, m) {
-		if (!this.parent) throw Error("not in slot");
+		if (!this.parent) throw errors.notInSlot;
 		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");
+		if (!this.isEqualOfCustomSlot(_, v)) throw errors.slotIncompatible;
+		if (!this.isValidOfCustomSlotProperty(_, v, y)) throw console.warn(`Sandbox/setCustomAdaptSlotProperty invalid custom slot property id=${e}`), errors.invalidCustomSlotProperty;
 		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));
 	}
@@ -11086,16 +10951,16 @@ var PromiseManager = class {
 	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 (!y) throw errors.nodeNotFound;
 		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");
+		console.assert(!1);
 	}
 	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");
+		if (!this.isValidOfElementMethod(m, g)) throw console.log(`Sandbox/callElementMethod invalid element method id=${e}`), errors.invalidElementMethod;
 		let _ = {};
 		return this.eventBus.emit(e, {
 			key: g,
@@ -11105,21 +10970,22 @@ var PromiseManager = class {
 	}
 	async callRefMethod(e, p, m, g) {
 		let _ = this.children[m];
-		if (!_) throw Error("sandbox not found");
-		if (!_.isValidOfCustomMethod(g)) throw console.warn(`Sandbox/callRefMethod invalid custom method id=${e}`), Error("invalid custom method");
+		if (!_) throw errors.sandboxNotFound;
+		if (!_.isValidOfCustomMethod(g)) throw console.warn(`Sandbox/callRefMethod invalid custom method id=${e}`), errors.invalidCustomMethod;
 		return await _.callFunctionAsync(getImplementMethodName("customMethod", "globality", g), "", p);
 	}
 	async callMultipleRefMethod(e, p, m, g, _) {
-		if (!p) throw Error("instance not available");
+		if (!p) throw errors.instanceNotAvailable;
 		let v = this.children[`${g}/${p}`];
-		if (!v) throw Error("sandbox not found");
-		if (!v.isValidOfCustomMethod(_)) throw console.warn(`Sandbox/callMultipleRefMethod invalid custom method id=${e}`), Error("invalid custom method");
+		if (!v) throw errors.sandboxNotFound;
+		if (!v.isValidOfCustomMethod(_)) throw console.warn(`Sandbox/callMultipleRefMethod invalid custom method id=${e}`), errors.invalidCustomMethod;
 		return await v.callFunctionAsync(getImplementMethodName("customMethod", "globality", _), "", m);
 	}
 	async callElementAdaptSlotMethod(e, p, m) {
-		if (!this.parent) throw Error("not in slot");
+		if (!this.parent) throw errors.notInSlot;
 		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");
+		if (!this.isEqualOfElementSlot(g, _)) throw errors.slotIncompatible;
+		if (!this.isValidOfElementSlotMethod(g, _, v)) throw console.warn(`Sandbox/callElementAdaptSlotMethod invalid element slot method id=${e}`), errors.invalidElementSlotMethod;
 		let y = {};
 		return this.eventBus.emit(`method/${v}`, {
 			instance: this.instance,
@@ -11128,12 +10994,163 @@ var PromiseManager = class {
 		}), y;
 	}
 	async callCustomAdaptSlotMethod(e, p, m) {
-		if (!this.parent) throw Error("not in slot");
+		if (!this.parent) throw errors.notInSlot;
 		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.isEqualOfCustomSlot(g, _)) throw errors.slotIncompatible;
+		if (!this.isValidOfCustomSlotMethod(g, _, v)) throw console.warn(`Sandbox/callCustomAdaptSlotMethod invalid custom slot method id=${e}`), errors.invalidCustomSlotMethod;
 		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");
+	}
+	isValidOfElementEvent(e, p) {
+		let m = getElement(e);
+		return !m || !m.events ? !1 : !!m.events.find((e) => e.key === p);
+	}
+	isValidOfElementSlotEvent(e, p, m) {
+		let g = getElement(e);
+		if (!g || !g.slots) return !1;
+		let _ = g.slots.find((e) => e.key === p);
+		return !_ || !_.events ? !1 : !!_.events.find((e) => e.key === m);
+	}
+	isValidOfCustomEvent(e) {
+		return this.meta.value ? !!this.meta.value.events?.find((p) => p.id === e) : !1;
+	}
+	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 errors.nodeNotFound;
+		g === "elementEvent" ? await this.triggerElementEvent(e, p, y, v) : g === "elementPropertyChangeEvent" ? await this.triggerElementPropertyChangeEvent(e, p, y, v) : g === "elementSlotEvent" ? await this.triggerElementSlotEvent(e, p, _, v) : g === "elementSlotPropertyChangeEvent" ? await this.triggerElementSlotPropertyChangeEvent(e, p, v) : g === "multipleElementSlotEvent" ? await this.triggerMultipleElementSlotEvent(e, p, _, v, m) : g === "multipleElementSlotPropertyChangeEvent" ? await this.triggerMultipleElementSlotPropertyChangeEvent(e, p, v, m) : g === "refEvent" ? await this.triggerRefEvent(e, p, _, v) : g === "refPropertyChangeEvent" ? await this.triggerRefPropertyChangeEvent(e, p, _, v) : g === "multipleRefEvent" ? await this.triggerMultipleRefEvent(e, p, _, v, m) : g === "multipleRefPropertyChangeEvent" ? await this.triggerMultipleRefPropertyChangeEvent(e, p, _, v, m) : g === "customSlotEvent" ? await this.triggerCustomSlotEvent(e, p, _, v) : g === "customSlotPropertyChangeEvent" ? await this.triggerCustomSlotPropertyChangeEvent(e, p, v) : g === "multipleCustomSlotEvent" ? await this.triggerMultipleCustomSlotEvent(e, p, _, v, m) : g === "multipleCustomSlotPropertyChangeEvent" ? await this.triggerMultipleCustomSlotPropertyChangeEvent(e, p, v, m) : g === "customEvent" ? await this.triggerCustomEvent(e, p, v) : g === "customPropertyChangeEvent" ? await this.triggerCustomPropertyChangeEvent(e, p, v) : g === "elementAdaptSlotEvent" ? await this.triggerElementAdaptSlotEvent(e, p, v) : g === "elementAdaptSlotPropertyChangeEvent" ? await this.triggerElementAdaptSlotPropertyChangeEvent(e, p, v) : g === "customAdaptSlotEvent" ? await this.triggerCustomAdaptSlotEvent(e, p, v) : g === "customAdaptSlotPropertyChangeEvent" ? await this.triggerCustomAdaptSlotPropertyChangeEvent(e, p, v) : g === "stateChangeEvent" ? await this.triggerStateChangeEvent(e, p, v) : console.assert(!1);
+	}
+	async triggerElementEvent(e, p, m, g) {
+		if (!this.isValidOfElementEvent(m.basic.key, g)) throw errors.invalidElementEvent;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerElementPropertyChangeEvent(e, p, m, g) {
+		if (!this.isValidOfElementProperty(m.basic.key, g)) throw errors.invalidElementProperty;
+		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 errors.invalidElementSlotEvent;
+		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 errors.invalidElementSlotProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerMultipleElementSlotEvent(e, p, m, g, _) {
+		if (!_) throw errors.instanceNotAvailable;
+		let { elementKey: v, slotKey: y, eventKey: b } = unwrapEventKeyOfElementSlot(g);
+		if (!this.isValidOfElementSlotEvent(v, y, b)) throw errors.invalidElementSlotEvent;
+		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 errors.instanceNotAvailable;
+		let { elementKey: _, slotKey: v, eventKey: y } = unwrapEventKeyOfElementSlot(m);
+		if (!this.isValidOfElementSlotProperty(_, v, y)) throw errors.invalidElementSlotProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p, g);
+	}
+	async triggerRefEvent(e, p, m, g) {
+		let _ = this.children[m];
+		if (!_) throw errors.sandboxNotFound;
+		if (!_.isValidOfCustomEvent(g)) throw errors.invalidCustomEvent;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerRefPropertyChangeEvent(e, p, m, g) {
+		let _ = this.children[m];
+		if (!_) throw errors.sandboxNotFound;
+		if (!_.isValidOfCustomProperty(g)) throw errors.invalidCustomProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerMultipleRefEvent(e, p, m, g, _) {
+		if (!_) throw errors.instanceNotAvailable;
+		let v = this.children[`${m}/${_}`];
+		if (!v) throw errors.sandboxNotFound;
+		if (!v.isValidOfCustomEvent(g)) throw errors.invalidCustomEvent;
+		await this.callFunctionAsync("__triggerEventInner__", e, p, _);
+	}
+	async triggerMultipleRefPropertyChangeEvent(e, p, m, g, _) {
+		if (!_) throw errors.instanceNotAvailable;
+		let v = this.children[`${m}/${_}`];
+		if (!v) throw errors.sandboxNotFound;
+		if (!v.isValidOfCustomProperty(g)) throw errors.invalidCustomProperty;
+		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 errors.invalidCustomSlotEvent;
+		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 errors.invalidCustomSlotProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerMultipleCustomSlotEvent(e, p, m, g, _) {
+		if (!_) throw errors.instanceNotAvailable;
+		let { compId: v, slotId: y, eventId: b } = unwrapEventKeyOfCustomSlot(g);
+		if (!this.isValidOfCustomSlotEvent(v, y, b)) throw errors.invalidCustomSlotEvent;
+		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 errors.instanceNotAvailable;
+		let { compId: _, slotId: v, eventId: y } = unwrapEventKeyOfCustomSlot(m);
+		if (!this.isValidOfCustomSlotProperty(_, v, y)) throw errors.invalidCustomSlotProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p, g);
+	}
+	async triggerCustomEvent(e, p, m) {
+		if (!this.isValidOfCustomEvent(m)) throw errors.invalidCustomEvent;
+		await this.callFunctionAsync("__triggerEventInner__", e, p), this.parent && (this.instance ? await this.parent.triggerEvent(makeEventId("multipleRefEvent", this.nodeId, m), p, this.instance) : await this.parent.triggerEvent(makeEventId("refEvent", this.nodeId, m), p));
+	}
+	async triggerCustomPropertyChangeEvent(e, p, m) {
+		if (!this.isValidOfCustomProperty(m)) throw errors.invalidCustomProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerElementAdaptSlotEvent(e, p, m) {
+		if (!this.parent) throw errors.notInSlot;
+		let { elementKey: g, slotKey: _, eventKey: v } = unwrapEventKeyOfElementSlot(m);
+		if (!this.isEqualOfElementSlot(g, _)) throw errors.slotIncompatible;
+		if (!this.isValidOfElementSlotEvent(g, _, v)) throw errors.invalidElementSlotEvent;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerElementAdaptSlotPropertyChangeEvent(e, p, m) {
+		if (!this.parent) throw errors.notInSlot;
+		let { elementKey: g, slotKey: _, eventKey: v } = unwrapEventKeyOfElementSlot(m);
+		if (!this.isEqualOfElementSlot(g, _)) throw errors.slotIncompatible;
+		if (!this.isValidOfElementSlotProperty(g, _, v)) throw errors.invalidElementSlotProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerCustomAdaptSlotEvent(e, p, m) {
+		if (!this.parent) throw errors.notInSlot;
+		let { compId: g, slotId: _, eventId: v } = unwrapEventKeyOfCustomSlot(m);
+		if (!this.isEqualOfCustomSlot(g, _)) throw errors.slotIncompatible;
+		if (!this.isValidOfCustomSlotEvent(g, _, v)) throw errors.invalidCustomSlotEvent;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerCustomAdaptSlotPropertyChangeEvent(e, p, m) {
+		if (!this.parent) throw errors.notInSlot;
+		let { compId: g, slotId: _, eventId: v } = unwrapEventKeyOfCustomSlot(m);
+		if (!this.isEqualOfCustomSlot(g, _)) throw errors.slotIncompatible;
+		if (!this.isValidOfCustomSlotProperty(g, _, v)) throw errors.invalidCustomSlotProperty;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
+	}
+	async triggerStateChangeEvent(e, p, m) {
+		if (!this.isValidOfState(m)) throw errors.invalidState;
+		await this.callFunctionAsync("__triggerEventInner__", e, p);
 	}
 	states = {};
 	resetStates() {
@@ -11146,7 +11163,7 @@ var PromiseManager = class {
 		return this.states[e];
 	}
 	async setState(e, p) {
-		if (this.debugTrace("setState", e, p), !this.isValidOfState(e)) throw console.warn(`Sandbox/setState invalid state id=${e}`), Error("invalid state");
+		if (this.debugTrace("setState", e, p), !this.isValidOfState(e)) throw console.warn(`Sandbox/setState invalid state id=${e}`), errors.invalidState;
 		let m = this.states[e];
 		isEqual_default(p, m) || (this.states[e] = cloneDeep_default(p), this.hooks.onStateChange(e, p, m), await nextTick());
 	}

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

@@ -1,4 +1,26 @@
 import { QuickJSContext } from 'quickjs-emscripten';
+export declare const errors: {
+    functionNotAvailable: Error;
+    instanceNotAvailable: Error;
+    invalidCustomEvent: Error;
+    invalidCustomMethod: Error;
+    invalidCustomProperty: Error;
+    invalidCustomSlotEvent: Error;
+    invalidCustomSlotMethod: Error;
+    invalidCustomSlotProperty: Error;
+    invalidElementEvent: Error;
+    invalidElementMethod: Error;
+    invalidElementProperty: Error;
+    invalidElementSlotEvent: Error;
+    invalidElementSlotMethod: Error;
+    invalidElementSlotProperty: Error;
+    invalidState: Error;
+    nodeNotFound: Error;
+    notInSlot: Error;
+    sandboxNotFound: Error;
+    slotIncompatible: Error;
+    vmNotAvailable: Error;
+};
 export type InitValues = {
     [key: string]: any;
 };

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

@@ -30,39 +30,15 @@ export declare class Sandbox {
     private data;
     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;
     setGlobalVariable(key: string, value: any): void;
     getGlobalVariable(key: string): any;
     callFunctionSync(funcName: string, ...params: any[]): any;
     callFunctionAsync(funcName: string, ...params: any[]): Promise<any>;
-    isValidOfElementEvent(elementKey: string, eventKey: string): boolean;
-    isValidOfElementSlotEvent(elementKey: string, slotKey: string, eventKey: string): boolean;
-    isValidOfCustomEvent(eventId: string): boolean;
-    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;
+    getNode(nodeId: string): Node | undefined;
+    isEqualOfElementSlot(elementKey: string, slotKey: string): boolean;
+    isEqualOfCustomSlot(compId: string, slotId: string): boolean;
     customProperties: {
         [key: string]: any;
     };
@@ -102,6 +78,32 @@ export declare class Sandbox {
     private callMultipleRefMethod;
     private callElementAdaptSlotMethod;
     private callCustomAdaptSlotMethod;
+    isValidOfElementEvent(elementKey: string, eventKey: string): boolean;
+    isValidOfElementSlotEvent(elementKey: string, slotKey: string, eventKey: string): boolean;
+    isValidOfCustomEvent(eventId: string): boolean;
+    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;
     private states;
     private resetStates;
     isValidOfState(id: string): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "x-runtime-lib",
   "private": false,
-  "version": "0.8.203",
+  "version": "0.8.205",
   "type": "module",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",