x-runtime-lib 0.8.197 → 0.8.199

package/dist/composables/element/core/elementSlotMethod.d.ts

@@ -1,3 +1,4 @@
+import { Sandbox } from '@/sandbox';
 interface Params {
     instance?: string;
     inputs: {
@@ -7,5 +8,5 @@ interface Params {
         [key: string]: any;
     };
 }
-export declare function useElementSlotMethod(slotKey: string, methodKey: string, hook: (params: Params) => void): void;
+export declare function useElementSlotMethod(sandbox: Sandbox | undefined, methodKey: string, hook: (params: Params) => void): void;
 export {};

package/dist/composables/element/core/elementSlotProperty.d.ts

@@ -1,2 +1,4 @@
 import { Ref } from 'vue';
-export declare function useElementSlotProperty(slotKey: string, propertyKey: string, target: Ref<any>): void;
+import { Sandbox } from '@/sandbox';
+import { Node } from '@/types';
+export declare function useElementSlotProperty(sandbox: Sandbox | undefined, node: Ref<Node>, propertyKey: string, target: Ref<any>): void;

package/dist/composables/runtime/sandbox.d.ts

@@ -1,4 +1,8 @@
 import { Ref } from 'vue';
 import { InitValues, Sandbox } from '@/sandbox';
 import { Data, Meta, SandboxKind } from '@/types';
-export declare function useSandbox(kind: SandboxKind, nodeId: string, slotId: string, instance: string, parent: Sandbox | undefined, meta: Ref<Meta | undefined>, data: Ref<Data | undefined>, initValues?: InitValues): void;
+export declare function useSandbox(kind: SandboxKind, nodeId: string, slotId: string, instance: string, parent: Sandbox | undefined, meta: Ref<Meta | undefined>, data: Ref<Data | undefined>, initValues?: InitValues): {
+    sandbox: undefined;
+} | {
+    sandbox: Sandbox;
+};

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

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

package/dist/index.js

@@ -1482,24 +1482,26 @@ function useElementProperty(e, p, m) {
 	}), { property: _ };
 }
 function useElementSlotMethod(e, p, m) {
-	let g = injectSandbox(), _ = `method/${e}/${p}`;
-	onBeforeMount(() => {
-		g?.eventBus.on(_, m);
+	e && (onBeforeMount(() => {
+		e.eventBus.on(`method/${p}`, m);
 	}), onUnmounted(() => {
-		g?.eventBus.off(_, m);
-	});
-}
-function useElementSlotProperty(e, p, m) {
-	let g = injectSandbox(), _ = `property/${e}/${p}`, v = (e) => {
-		e.result.value = m.value;
-	}, y = (e) => {
-		m.value = e;
+		e.eventBus.off(`method/${p}`, m);
+	}));
+}
+function useElementSlotProperty(e, p, m, g) {
+	if (!e) return;
+	let _ = (e) => {
+		e.result.value = g.value;
+	}, v = (e) => {
+		g.value = e;
 	};
 	onBeforeMount(() => {
-		g?.eventBus.on(`${_}/get`, v), g?.eventBus.on(`${_}/set`, y);
+		e.eventBus.on(`property/${m}/get`, _), e.eventBus.on(`property/${m}/set`, v);
 	}), onUnmounted(() => {
-		g?.eventBus.off(`${_}/get`, v), g?.eventBus.off(`${_}/set`, y);
-	});
+		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);
+	}, { immediate: !0 });
 }
 function useElementSlotRender(e, p, m) {
 	function g(p) {
@@ -3779,7 +3781,7 @@ var v1_default$40 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 			_: 3
 		}));
 	}
-}), slotKey$4 = "column", columnSlot_default = /* @__PURE__ */ defineComponent({
+}), columnSlot_default = /* @__PURE__ */ defineComponent({
 	__name: "columnSlot",
 	props: /* @__PURE__ */ mergeModels({
 		refContext: {},
@@ -3793,9 +3795,11 @@ var v1_default$40 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 		let p = useModel(e, "value"), m = e, g = injectId(), _ = injectNode(), v = ref();
 		provideMeta(v);
 		let y = ref();
-		provideData(y), useDepend(computed(() => m.refContext.compId), v, y), useSandbox("multipleElementSlot", _.value.basic.id, slotKey$4, m.instance, injectSandbox(), v, y), useElementSlotProperty(slotKey$4, "value", p);
-		let { render: b } = useElementSlotRender(m.refContext, g, y);
-		return (e, p) => (openBlock(), createBlock(unref(b)));
+		provideData(y), useDepend(computed(() => m.refContext.compId), v, y);
+		let { sandbox: b } = useSandbox("multipleElementSlot", _.value.basic.id, "column", m.instance, injectSandbox(), v, y);
+		useElementSlotProperty(b, _, "value", p);
+		let { render: x } = useElementSlotRender(m.refContext, g, y);
+		return (e, p) => (openBlock(), createBlock(unref(x)));
 	}
 }), v1_default$31 = /* @__PURE__ */ defineComponent({
 	__name: "index",
@@ -3807,26 +3811,32 @@ var v1_default$40 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 	setup(e) {
 		let p = e, { node: m } = useElementBase(p);
 		provideNode(m);
-		let { property: g } = useElementProperty(m, ["settings", "density"]), { property: _ } = useElementProperty(m, ["settings", "fixedFooter"]), { property: v } = useElementProperty(m, ["settings", "fixedHeader"]), { property: y } = useElementProperty(m, ["settings", "headers"]), { property: b } = useElementProperty(m, ["size", "height"]), { property: x } = useElementProperty(m, ["settings", "hover"]), { property: S } = useElementProperty(m, ["settings", "data"], !0), { property: C } = useElementProperty(m, ["settings", "loading"]), { property: w } = useElementProperty(m, ["settings", "multiSort"]), { theme: T } = useTheme(), { property: E } = useElementProperty(m, ["size", "width"]), { property: D } = useElementProperty(m, ["slots", "columns"]);
+		let g = injectMode(), { property: _ } = useElementProperty(m, ["settings", "density"]), { property: v } = useElementProperty(m, ["settings", "fixedFooter"]), { property: y } = useElementProperty(m, ["settings", "fixedHeader"]), { property: b } = useElementProperty(m, ["settings", "headers"]), { property: x } = useElementProperty(m, ["size", "height"]), { property: S } = useElementProperty(m, ["settings", "hover"]), { property: C } = useElementProperty(m, ["settings", "data"], !0), { property: w } = useElementProperty(m, ["settings", "loading"]), { property: T } = useElementProperty(m, ["settings", "multiSort"]), { theme: E } = useTheme(), { property: D } = useElementProperty(m, ["size", "width"]), O = ref([]);
+		if (isExecutableMode(g)) {
+			let { property: e } = useElementProperty(m, ["slots", "columns"]);
+			watchEffect(() => {
+				O.value = e.value;
+			});
+		}
 		return (e, m) => {
-			let O = resolveComponent("v-data-table");
+			let g = resolveComponent("v-data-table");
 			return openBlock(), createBlock(unref(wrap_default), {
 				block: "",
 				mask: ""
 			}, {
-				default: withCtx(() => [createVNode(O, {
-					density: unref(g),
-					"fixed-footer": unref(_),
-					"fixed-header": unref(v),
-					headers: unref(y),
-					height: unref(b),
-					hover: unref(x),
-					items: unref(S),
-					loading: unref(C),
-					"multi-sort": unref(w),
-					theme: unref(T),
-					width: unref(E)
-				}, createSlots({ _: 2 }, [renderList(unref(D), ({ key: e, comp: m }) => ({
+				default: withCtx(() => [createVNode(g, {
+					density: unref(_),
+					"fixed-footer": unref(v),
+					"fixed-header": unref(y),
+					headers: unref(b),
+					height: unref(x),
+					hover: unref(S),
+					items: unref(C),
+					loading: unref(w),
+					"multi-sort": unref(T),
+					theme: unref(E),
+					width: unref(D)
+				}, createSlots({ _: 2 }, [renderList(O.value, ({ key: e, comp: m }) => ({
 					name: `item.${e}`,
 					fn: withCtx(({ value: g }) => [createVNode(columnSlot_default, {
 						instance: e,
@@ -4983,7 +4993,7 @@ var v1_default$11 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 			});
 		};
 	}
-}), slotKey$3 = "appendInner", appendInnerSlot_default = /* @__PURE__ */ defineComponent({
+}), appendInnerSlot_default = /* @__PURE__ */ defineComponent({
 	__name: "appendInnerSlot",
 	props: /* @__PURE__ */ mergeModels({
 		refContext: {},
@@ -5006,15 +5016,17 @@ var v1_default$11 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 		let p = useModel(e, "isActive"), m = useModel(e, "isFocused"), g = e, _ = injectId(), v = injectNode(), y = ref();
 		provideMeta(y);
 		let b = ref();
-		provideData(b), useDepend(computed(() => g.refContext.compId), y, b), useSandbox("elementSlot", v.value.basic.id, slotKey$3, "", injectSandbox(), y, b), useElementSlotProperty(slotKey$3, "isActive", p), useElementSlotProperty(slotKey$3, "isFocused", m), useElementSlotMethod(slotKey$3, "focus", () => {
+		provideData(b), useDepend(computed(() => g.refContext.compId), y, b);
+		let { sandbox: x } = useSandbox("elementSlot", v.value.basic.id, "appendInner", "", injectSandbox(), y, b);
+		useElementSlotProperty(x, v, "isActive", p), useElementSlotProperty(x, v, "isFocused", m), useElementSlotMethod(x, "focus", () => {
 			g.focus();
-		}), useElementSlotMethod(slotKey$3, "blur", () => {
+		}), useElementSlotMethod(x, "blur", () => {
 			g.blur();
 		});
-		let { render: x } = useElementSlotRender(g.refContext, _, b);
-		return (e, p) => (openBlock(), createBlock(unref(x)));
+		let { render: S } = useElementSlotRender(g.refContext, _, b);
+		return (e, p) => (openBlock(), createBlock(unref(S)));
 	}
-}), slotKey$2 = "append", appendSlot_default = /* @__PURE__ */ defineComponent({
+}), appendSlot_default = /* @__PURE__ */ defineComponent({
 	__name: "appendSlot",
 	props: {
 		refContext: {},
@@ -5026,17 +5038,19 @@ var v1_default$11 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 		let p = e, m = injectId(), g = injectNode(), _ = ref();
 		provideMeta(_);
 		let v = ref();
-		provideData(v), useDepend(computed(() => p.refContext.compId), _, v), useSandbox("elementSlot", g.value.basic.id, slotKey$2, "", injectSandbox(), _, v), useElementSlotMethod(slotKey$2, "reset", () => {
+		provideData(v), useDepend(computed(() => p.refContext.compId), _, v);
+		let { sandbox: y } = useSandbox("elementSlot", g.value.basic.id, "append", "", injectSandbox(), _, v);
+		useElementSlotMethod(y, "reset", () => {
 			p.reset();
-		}), useElementSlotMethod(slotKey$2, "resetValidation", () => {
+		}), useElementSlotMethod(y, "resetValidation", () => {
 			p.resetValidation();
-		}), useElementSlotMethod(slotKey$2, "validate", () => {
+		}), useElementSlotMethod(y, "validate", () => {
 			p.validate();
 		});
-		let { render: y } = useElementSlotRender(p.refContext, m, v);
-		return (e, p) => (openBlock(), createBlock(unref(y)));
+		let { render: b } = useElementSlotRender(p.refContext, m, v);
+		return (e, p) => (openBlock(), createBlock(unref(b)));
 	}
-}), slotKey$1 = "prependInner", prependInnerSlot_default = /* @__PURE__ */ defineComponent({
+}), prependInnerSlot_default = /* @__PURE__ */ defineComponent({
 	__name: "prependInnerSlot",
 	props: /* @__PURE__ */ mergeModels({
 		refContext: {},
@@ -5059,15 +5073,17 @@ var v1_default$11 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 		let p = useModel(e, "isActive"), m = useModel(e, "isFocused"), g = e, _ = injectId(), v = injectNode(), y = ref();
 		provideMeta(y);
 		let b = ref();
-		provideData(b), useDepend(computed(() => g.refContext.compId), y, b), useSandbox("elementSlot", v.value.basic.id, slotKey$1, "", injectSandbox(), y, b), useElementSlotProperty(slotKey$1, "isActive", p), useElementSlotProperty(slotKey$1, "isFocused", m), useElementSlotMethod(slotKey$1, "focus", () => {
+		provideData(b), useDepend(computed(() => g.refContext.compId), y, b);
+		let { sandbox: x } = useSandbox("elementSlot", v.value.basic.id, "prependInner", "", injectSandbox(), y, b);
+		useElementSlotProperty(x, v, "isActive", p), useElementSlotProperty(x, v, "isFocused", m), useElementSlotMethod(x, "focus", () => {
 			g.focus();
-		}), useElementSlotMethod(slotKey$1, "blur", () => {
+		}), useElementSlotMethod(x, "blur", () => {
 			g.blur();
 		});
-		let { render: x } = useElementSlotRender(g.refContext, _, b);
-		return (e, p) => (openBlock(), createBlock(unref(x)));
+		let { render: S } = useElementSlotRender(g.refContext, _, b);
+		return (e, p) => (openBlock(), createBlock(unref(S)));
 	}
-}), slotKey = "prepend", prependSlot_default = /* @__PURE__ */ defineComponent({
+}), prependSlot_default = /* @__PURE__ */ defineComponent({
 	__name: "prependSlot",
 	props: {
 		refContext: {},
@@ -5079,15 +5095,17 @@ var v1_default$11 = /* @__PURE__ */ __plugin_vue_export_helper_default(_sfc_main
 		let p = e, m = injectId(), g = injectNode(), _ = ref();
 		provideMeta(_);
 		let v = ref();
-		provideData(v), useDepend(computed(() => p.refContext.compId), _, v), useSandbox("elementSlot", g.value.basic.id, slotKey, "", injectSandbox(), _, v), useElementSlotMethod(slotKey, "reset", () => {
+		provideData(v), useDepend(computed(() => p.refContext.compId), _, v);
+		let { sandbox: y } = useSandbox("elementSlot", g.value.basic.id, "prepend", "", injectSandbox(), _, v);
+		useElementSlotMethod(y, "reset", () => {
 			p.reset();
-		}), useElementSlotMethod(slotKey, "resetValidation", () => {
+		}), useElementSlotMethod(y, "resetValidation", () => {
 			p.resetValidation();
-		}), useElementSlotMethod(slotKey, "validate", () => {
+		}), useElementSlotMethod(y, "validate", () => {
 			p.validate();
 		});
-		let { render: y } = useElementSlotRender(p.refContext, m, v);
-		return (e, p) => (openBlock(), createBlock(unref(y)));
+		let { render: b } = useElementSlotRender(p.refContext, m, v);
+		return (e, p) => (openBlock(), createBlock(unref(b)));
 	}
 }), v1_default$4 = /* @__PURE__ */ defineComponent({
 	__name: "index",
@@ -5983,7 +6001,7 @@ const orbitControlsV1 = {
 	leaf: !0
 };
 regElement(orbitControlsV1);
-function spawn$16(e, p) {
+function spawn$17(e, p) {
 	let m = getElementMust("3d_mesh_v1"), g = getProperties(m, e, p), _ = initNode();
 	initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key, _.transform = {
 		position: {
@@ -6090,10 +6108,10 @@ const boxGeometryV1 = {
 	methods: [],
 	slots: [],
 	leaf: !0,
-	spawn: spawn$16
+	spawn: spawn$17
 };
 regElement(boxGeometryV1);
-function spawn$15(e, p) {
+function spawn$16(e, p) {
 	let m = getElementMust("3d_mesh_v1"), g = getProperties(m, e, p), _ = initNode();
 	initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key, _.transform = {
 		position: {
@@ -6209,7 +6227,7 @@ const sphereGeometryV1 = {
 	methods: [],
 	slots: [],
 	leaf: !0,
-	spawn: spawn$15
+	spawn: spawn$16
 };
 regElement(sphereGeometryV1);
 var color$4 = cloneDeep_default(colorV1);
@@ -6439,7 +6457,7 @@ const meshV1 = {
 	slots: []
 };
 regElement(meshV1);
-function spawn$14(e, p) {
+function spawn$15(e, p) {
 	let m = getElementMust("ui_bar_chart_v1"), g = getProperties(m, e, p), _ = initNode();
 	return initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key, _.size.height = "300px", _.xAxis.data = [
 		"Mon",
@@ -6509,10 +6527,10 @@ const barChartV1 = {
 		]
 	},
 	leaf: !0,
-	spawn: spawn$14
+	spawn: spawn$15
 };
 regElement(barChartV1);
-function spawn$13(e, p) {
+function spawn$14(e, p) {
 	let m = getElementMust("ui_line_chart_v1"), g = getProperties(m, e, p), _ = initNode();
 	return initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key, _.size.height = "300px", _.xAxis.data = [
 		"Mon",
@@ -6582,7 +6600,7 @@ const lineChartV1 = {
 		]
 	},
 	leaf: !0,
-	spawn: spawn$13
+	spawn: spawn$14
 };
 regElement(lineChartV1);
 var settings$37 = {
@@ -6904,7 +6922,7 @@ const badgeV1 = {
 	}
 };
 regElement(badgeV1);
-function spawn$12(e, p) {
+function spawn$13(e, p) {
 	let m = getElementMust("ui_btn_v1"), g = getProperties(m, e, p), _ = initNode();
 	return initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key, _.settings.text = "button", {
 		nodeLite: toNodeLite(_),
@@ -7017,7 +7035,7 @@ const btnV1 = {
 		name: "x-runtime-lib.click"
 	}],
 	leaf: !0,
-	spawn: spawn$12
+	spawn: spawn$13
 };
 regElement(btnV1);
 const btnGroupV1 = {
@@ -7102,7 +7120,7 @@ const btnToggleV1 = {
 	}
 };
 regElement(btnToggleV1);
-function spawn$11(e, p) {
+function spawn$12(e, p) {
 	let m = getElementMust("ui_card_v1"), g = getProperties(m, e, p), _ = initNode();
 	return initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key, _.children = [], _.settings.title = "title", _.settings.subtitle = "subtitle", _.settings.text = "text", {
 		nodeLite: toNodeLite(_),
@@ -7181,7 +7199,7 @@ const cardV1 = {
 			settings$29
 		]
 	},
-	spawn: spawn$11
+	spawn: spawn$12
 };
 regElement(cardV1);
 var settings$28 = {
@@ -7297,7 +7315,7 @@ const chipV1 = {
 	leaf: !0
 };
 regElement(chipV1);
-function spawn$10(e, p) {
+function spawn$11(e, p) {
 	let m = getElementMust("ui_chip_group_v1"), g = getProperties(m, e, p), _ = initNode();
 	initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key;
 	let v = spawnChip(e, p, "chip1", "chip 1"), y = spawnChip(e, p, "chip2", "chip 2"), b = spawnChip(e, p, "chip3", "chip 3"), x = spawnChip(e, p, "chip4", "chip 4"), S = spawnChip(e, p, "chip5", "chip 5"), C = spawnChip(e, p, "chip6", "chip 6");
@@ -7391,7 +7409,7 @@ const chipGroupV1 = {
 		pageUi: [basicV1, settings$26],
 		compUi: [basicV1, settings$26]
 	},
-	spawn: spawn$10
+	spawn: spawn$11
 };
 regElement(chipGroupV1);
 const colorPickerV1 = {
@@ -7493,6 +7511,19 @@ const containerV1 = {
 	}]
 };
 regElement(containerV1);
+function spawn$10(e, p) {
+	let m = getElementMust("ui_data_table_v1"), g = getProperties(m, e, p), _ = initNode();
+	return initProperties(_, g), _.basic.id = genId(16), _.basic.key = m.key, _.settings.headers = [{
+		value: "name",
+		title: "Name"
+	}, {
+		value: "price",
+		title: "Price"
+	}], _.settings.data = "[\n  { \"name\": \"Apple\", \"price\": 5.5 },\n  { \"name\": \"Orange\", \"price\": 3.0 },\n  { \"name\": \"Berry\", \"price\": 13.5 }\n]", {
+		nodeLite: toNodeLite(_),
+		nodes: { [_.basic.id]: _ }
+	};
+}
 var size$1 = {
 	key: "size",
 	name: "x-runtime-lib.size",
@@ -7667,7 +7698,8 @@ const dataTableV1 = {
 			readonly: !0
 		}]
 	}],
-	leaf: !0
+	leaf: !0,
+	spawn: spawn$10
 };
 regElement(dataTableV1);
 const datePickerV1 = {
@@ -10626,6 +10658,9 @@ var PromiseManager = class {
 	prepare(e, p, m) {
 		this.meta.value = e.value, this.data.value = p.value, this.resetProperties(m), 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();
 	}
@@ -10738,11 +10773,9 @@ var PromiseManager = class {
 		return !m || !m.properties ? !1 : !!m.properties.find((e) => e.id === p);
 	}
 	async getProperty(e, p) {
-		let { kind: m, nodeId: g, propertyKey: _ } = unwrapPropertyId(e), v = this.data.value?.view.nodes[g];
+		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, _);
@@ -10756,21 +10789,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/${v}/${y}/get`, { result: x }), x.value;
-	}
 	async getRefProperty(e, p, m) {
 		let g = this.children[p];
 		if (!g) throw Error("sandbox not found");
@@ -10815,11 +10833,9 @@ var PromiseManager = class {
 		return this.customSlotProperties[g];
 	}
 	async setProperty(e, p, m) {
-		let { kind: g, nodeId: v, propertyKey: y } = unwrapPropertyId(e), b = this.data.value?.view.nodes[v];
+		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);
@@ -10835,25 +10851,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/${y}/${b}/get`, { result: S });
-		let C = S.value;
-		isEqual_default(p, C) || (x.eventBus.emit(`property/${y}/${b}/set`, p), x.hooks.onPropertyChange(makePropertyId("elementAdaptSlotProperty", "globality", _), p, C), this.hooks.onPropertyChange(e, p, C));
-	}
-	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/${b}/${x}/get`, { result: C });
-		let w = C.value;
-		isEqual_default(p, w) || (S.eventBus.emit(`property/${b}/${x}/set`, p), S.hooks.onPropertyChange(makePropertyId("elementAdaptSlotProperty", "globality", _), p, w, v), this.hooks.onPropertyChange(e, p, w, v));
-	}
 	async setRefProperty(e, p, m, _) {
 		let v = this.children[m];
 		if (!v) throw Error("sandbox not found");
@@ -10925,16 +10922,14 @@ 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.data.value?.view.nodes[_];
+		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");
@@ -10945,27 +10940,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/${v}/${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/${y}/${b}`, {
-			inputs: m,
-			outputs: S
-		}), S;
-	}
 	async callRefMethod(e, p, m, g) {
 		let _ = this.children[m];
 		if (!_) throw Error("sandbox not found");
@@ -10984,7 +10958,8 @@ 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;
@@ -11015,7 +10990,7 @@ 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();
-	if (!isExecutableMode(w)) return;
+	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,
@@ -11056,13 +11031,13 @@ 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));
 	}
-	watch(E, async (e, p) => {
+	return watch(E, async (e, p) => {
 		if (!k.vm) return;
 		let m = calcBreakpoint(e.width), g = calcBreakpoint(p?.width ?? e.width);
 		await k.callFunctionAsync("__triggerEventV1__", makeEventId("elementEvent", "globality", "screenSizeChange"), "", m, g);
 	}), watch(D, async (e) => {
 		k.vm && await k.callFunctionAsync("__triggerEventV1__", makeEventId("elementEvent", "globality", "darkModeChange"), "", e);
-	});
+	}), { sandbox: k };
 }
 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, SandboxKind } from '@/types';
+import { Data, Env, Meta, Mode, Node, SandboxKind } from '@/types';
 import { InitValues, Inputs } from '../common';
 import { Hooks } from './hooks';
 import { PromiseManager } from './promiseManager';
@@ -29,6 +29,7 @@ export declare class Sandbox {
     private meta;
     private data;
     prepare(meta: Ref<Meta | undefined>, data: Ref<Data | undefined>, initValues?: InitValues): void;
+    getNode(nodeId: string): Node | undefined;
     createVm(runtime: QuickJSRuntime, code: string): Promise<void>;
     destroyVm(): void;
     setGlobalVariable(key: string, value: any): void;
@@ -53,8 +54,6 @@ export declare class Sandbox {
     isValidOfCustomSlotProperty(slotId: string, propertyId: string): boolean;
     getProperty(id: string, instance?: string): Promise<any>;
     private getElementProperty;
-    private getElementSlotProperty;
-    private getMultipleElementSlotProperty;
     private getRefProperty;
     private getMultipleRefProperty;
     private getCustomSlotProperty;
@@ -64,8 +63,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,10 +74,8 @@ export declare class Sandbox {
     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>;
+    callMethod(id: string, instance: string, inputs: Inputs): Promise<any>;
     private callElementMethod;
-    private callElementSlotMethod;
-    private callMultipleElementSlotMethod;
     private callRefMethod;
     private callMultipleRefMethod;
     private callElementAdaptSlotMethod;

package/package.json

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