x-runtime-lib 0.8.198 → 0.8.199

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

@@ -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) {
@@ -10776,8 +10776,6 @@ var PromiseManager = class {
 		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 +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/${y}/get`, { result: x }), x.value;
-	}
 	async getRefProperty(e, p, m) {
 		let g = this.children[p];
 		if (!g) throw Error("sandbox not found");
@@ -10853,8 +10836,6 @@ var PromiseManager = class {
 		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 +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/${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");
@@ -10962,14 +10924,12 @@ var PromiseManager = class {
 		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 +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/${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,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;

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

@@ -54,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;
@@ -65,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;
@@ -78,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.198",
+  "version": "0.8.199",
   "type": "module",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",