@zeus-js/web-c-runtime 0.1.1-beta.15 → 0.1.1-beta.17

package/dist/web-c-runtime.esm-bundler.js

@@ -1,5 +1,5 @@
 /**
-* web-c-runtime v0.1.1-beta.15
+* web-c-runtime v0.1.1-beta.17
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
@@ -218,9 +218,14 @@ function _asyncToGenerator(n) {
 //#endregion
 //#region packages/web-c/web-c-runtime/src/lifecycle.ts
 const moduleCache = /* @__PURE__ */ new WeakMap();
+const ancestorWaitCancellations = /* @__PURE__ */ new WeakMap();
+function cancelAncestorWait(hostRef) {
+	var _ancestorWaitCancella;
+	(_ancestorWaitCancella = ancestorWaitCancellations.get(hostRef)) === null || _ancestorWaitCancella === void 0 || _ancestorWaitCancella();
+}
 function waitForComponentReady(hostRef) {
-	if (hostRef.loaded) return Promise.resolve(hostRef.host);
 	if (hostRef.readinessError) return Promise.reject(hostRef.readinessError);
+	if (hostRef.loaded && !hostRef.loading) return Promise.resolve(hostRef.host);
 	return new Promise((resolve, reject) => {
 		hostRef.readyWaiters.push({
 			resolve,
@@ -238,18 +243,18 @@ function initializeComponent(_x) {
 }
 function _initializeComponent() {
 	_initializeComponent = _asyncToGenerator(function* (hostRef) {
-		if (hostRef.loaded) {
-			var _hostRef$instance, _hostRef$instance$con;
-			(_hostRef$instance = hostRef.instance) === null || _hostRef$instance === void 0 || (_hostRef$instance$con = _hostRef$instance.connected) === null || _hostRef$instance$con === void 0 || _hostRef$instance$con.call(_hostRef$instance);
-			flushPendingFormCallbacks(hostRef);
-			return;
-		}
 		if (hostRef.loading) {
 			yield hostRef.loading;
 			if (hostRef.connected && !hostRef.loaded) yield initializeComponent(hostRef);
 			return;
 		}
-		const loading = doInitializeComponent(hostRef);
+		if (hostRef.loaded && !findPendingAncestor(hostRef.host)) {
+			var _hostRef$instance, _hostRef$instance$con;
+			(_hostRef$instance = hostRef.instance) === null || _hostRef$instance === void 0 || (_hostRef$instance$con = _hostRef$instance.connected) === null || _hostRef$instance$con === void 0 || _hostRef$instance$con.call(_hostRef$instance);
+			flushPendingFormCallbacks(hostRef);
+			return;
+		}
+		const loading = hostRef.loaded ? reconnectComponent(hostRef) : doInitializeComponent(hostRef);
 		hostRef.loading = loading;
 		try {
 			yield loading;
@@ -259,6 +264,7 @@ function _initializeComponent() {
 		} finally {
 			if (hostRef.loading === loading) hostRef.loading = void 0;
 		}
+		if (hostRef.connected && hostRef.loaded) resolveReadyWaiters(hostRef);
 	});
 	return _initializeComponent.apply(this, arguments);
 }
@@ -269,6 +275,7 @@ function _doInitializeComponent() {
 	_doInitializeComponent = _asyncToGenerator(function* (hostRef) {
 		applyInitialValues(hostRef);
 		const mod = yield loadComponentModule(hostRef);
+		yield waitForAncestors(hostRef);
 		if (!hostRef.connected) return;
 		const instance = mod.createComponent(hostRef);
 		hostRef.instance = instance;
@@ -279,7 +286,6 @@ function _doInitializeComponent() {
 			const rendered = (_instance$render = instance.render) === null || _instance$render === void 0 ? void 0 : _instance$render.call(instance);
 			if (rendered !== void 0) mountRenderedOutput(hostRef, rendered);
 			hostRef.loaded = true;
-			resolveReadyWaiters(hostRef);
 		} catch (error) {
 			var _instance$dispose;
 			hostRef.instance = void 0;
@@ -290,13 +296,81 @@ function _doInitializeComponent() {
 	});
 	return _doInitializeComponent.apply(this, arguments);
 }
+function reconnectComponent(_x3) {
+	return _reconnectComponent.apply(this, arguments);
+}
+function _reconnectComponent() {
+	_reconnectComponent = _asyncToGenerator(function* (hostRef) {
+		var _hostRef$instance2, _hostRef$instance2$co;
+		yield waitForAncestors(hostRef);
+		if (!hostRef.connected) return;
+		(_hostRef$instance2 = hostRef.instance) === null || _hostRef$instance2 === void 0 || (_hostRef$instance2$co = _hostRef$instance2.connected) === null || _hostRef$instance2$co === void 0 || _hostRef$instance2$co.call(_hostRef$instance2);
+		flushPendingFormCallbacks(hostRef);
+	});
+	return _reconnectComponent.apply(this, arguments);
+}
+function waitForAncestors(_x4) {
+	return _waitForAncestors.apply(this, arguments);
+}
+function _waitForAncestors() {
+	_waitForAncestors = _asyncToGenerator(function* (hostRef) {
+		let ancestor = findPendingAncestor(hostRef.host);
+		while (hostRef.connected && ancestor) {
+			try {
+				yield waitForAncestorReady(hostRef, ancestor);
+			} catch (error) {
+				if (hostRef.connected && ancestor.connected && ancestor.readinessError === error && findPendingAncestor(hostRef.host) === ancestor) throw error;
+			}
+			ancestor = findPendingAncestor(hostRef.host);
+		}
+	});
+	return _waitForAncestors.apply(this, arguments);
+}
+function waitForAncestorReady(hostRef, ancestor) {
+	if (ancestor.readinessError) return Promise.reject(ancestor.readinessError);
+	if (ancestor.loaded && !ancestor.loading) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			const index = ancestor.readyWaiters.indexOf(waiter);
+			if (index >= 0) ancestor.readyWaiters.splice(index, 1);
+			if (ancestorWaitCancellations.get(hostRef) === cancel) ancestorWaitCancellations.delete(hostRef);
+		};
+		const cancel = () => {
+			cleanup();
+			resolve();
+		};
+		const waiter = {
+			resolve() {
+				cleanup();
+				resolve();
+			},
+			reject(error) {
+				cleanup();
+				reject(error);
+			}
+		};
+		ancestorWaitCancellations.set(hostRef, cancel);
+		ancestor.readyWaiters.push(waiter);
+	});
+}
+function findPendingAncestor(host) {
+	let node = host.parentNode;
+	while (node) {
+		var _node$parentNode;
+		if (node.nodeType === 1) {
+			const ancestor = getHostRef(node);
+			if ((ancestor === null || ancestor === void 0 ? void 0 : ancestor.connected) && (!ancestor.loaded || ancestor.loading || ancestor.readinessError)) return ancestor;
+		}
+		node = (_node$parentNode = node.parentNode) !== null && _node$parentNode !== void 0 ? _node$parentNode : node.nodeType === 11 ? node.host : null;
+	}
+}
 function flushPendingFormCallbacks(hostRef) {
 	while (hostRef.pendingFormCallbacks.length > 0) {
 		invokeFormCallback(hostRef, hostRef.pendingFormCallbacks[0]);
 		hostRef.pendingFormCallbacks.shift();
 	}
 }
-function loadComponentModule(_x3) {
+function loadComponentModule(_x5) {
 	return _loadComponentModule.apply(this, arguments);
 }
 function _loadComponentModule() {
@@ -365,10 +439,11 @@ function createLazyElementClass(meta) {
 			});
 		}
 		disconnectedCallback() {
-			if (isWithinRuntimeDomMove(this)) return;
 			const hostRef = requireHostRef(this);
+			cancelAncestorWait(hostRef);
+			if (isWithinRuntimeDomMove(this)) return;
 			hostRef.connected = false;
-			if (!hostRef.loaded) rejectComponentReady(hostRef, /* @__PURE__ */ new Error(`[ZEUS_WC_DISCONNECTED_BEFORE_READY] <${meta.tagName}> disconnected before initialization completed.`));
+			if (!hostRef.loaded || hostRef.loading) rejectComponentReady(hostRef, /* @__PURE__ */ new Error(`[ZEUS_WC_DISCONNECTED_BEFORE_READY] <${meta.tagName}> disconnected before initialization completed.`));
 			if (hostRef.loaded) try {
 				var _hostRef$instance, _hostRef$instance$dis;
 				(_hostRef$instance = hostRef.instance) === null || _hostRef$instance === void 0 || (_hostRef$instance$dis = _hostRef$instance.disconnected) === null || _hostRef$instance$dis === void 0 || _hostRef$instance$dis.call(_hostRef$instance);
@@ -412,7 +487,7 @@ function createLazyElementClass(meta) {
 	}
 	ZeusLazyElement.formAssociated = Boolean(meta.formAssociated);
 	installPropertyAccessors(ZeusLazyElement.prototype, meta.props);
-	installMethodProxies(ZeusLazyElement.prototype, meta.methods);
+	installMethodProxies(ZeusLazyElement.prototype, meta.methods, meta.tagName);
 	return ZeusLazyElement;
 }
 function dispatchFormCallback(hostRef, callback) {
@@ -422,10 +497,11 @@ function dispatchFormCallback(hostRef, callback) {
 	}
 	invokeFormCallback(hostRef, callback);
 }
-function installMethodProxies(proto, methods) {
+function installMethodProxies(proto, methods, tagName) {
 	if (!methods) return;
+	const reservedNames = new Set(Object.getOwnPropertyNames(proto));
 	for (const name of methods) {
-		if (name in proto) continue;
+		if (reservedNames.has(name)) throw new Error(`[ZEUS_WC_RESERVED_METHOD] Method "${name}" conflicts with a lazy element lifecycle/API method on <${tagName}>.`);
 		Object.defineProperty(proto, name, {
 			configurable: true,
 			value: function() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zeus-js/web-c-runtime",
   "type": "module",
-  "version": "0.1.1-beta.15",
+  "version": "0.1.1-beta.17",
   "description": "Zeus Web-C lazy-loading runtime",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
     "dist"
   ],
   "dependencies": {
-    "@zeus-js/runtime-dom": "0.1.1-beta.15"
+    "@zeus-js/runtime-dom": "0.1.1-beta.17"
   },
   "author": "Baicie",
   "buildOptions": {