@zeus-js/web-c-runtime 0.1.1-beta.12 → 0.1.1-beta.14

package/dist/web-c-runtime.d.ts

@@ -1,4 +1,4 @@
-import { CustomElementPropSchema, CustomElementPropType } from '@zeus-js/runtime-dom';
+import { NormalizedPropChange, CustomElementPropSchema, CustomElementPropType } from '@zeus-js/runtime-dom';
 
 export type ZeusPropType = CustomElementPropType;
 export interface ZeusPropMeta extends CustomElementPropSchema {
@@ -36,10 +36,15 @@ export interface HostRef {
     connected: boolean;
     loaded: boolean;
     loading?: Promise<void>;
+    readinessError?: Error;
+    exposedMethods: Record<string, Function>;
     instance?: ZeusComponentInstance;
     values: Map<string, unknown>;
+    propDefinitions: ZeusPropMeta[];
     attributeProps: Set<string>;
     reflectingAttrs: Set<string>;
+    preUpgradeAttributes: Map<string, string>;
+    pendingAttributes: Map<string, string | null>;
     pendingFormCallbacks: ZeusFormCallback[];
     readyWaiters: Array<{
         resolve(host: HTMLElement): void;
@@ -49,7 +54,7 @@ export interface HostRef {
 export interface ZeusComponentInstance {
     connected?(): void;
     disconnected?(): void;
-    propertyChanged?(name: string, oldValue: unknown, newValue: unknown): void;
+    propertyChanged?(change: NormalizedPropChange): void;
     formAssociated?(form: HTMLFormElement | null): void;
     formDisabled?(disabled: boolean): void;
     formReset?(): void;
@@ -85,4 +90,7 @@ export declare function bootstrapLazy(components: ZeusLazyComponentMeta[], optio
 
 export declare function createLazyElementClass(meta: ZeusLazyComponentMeta): CustomElementConstructor;
 
+/** Replace deferred codec markers with the implementation's real schema. */
+export declare function resolveHostProperties(hostRef: HostRef, definitions: ZeusPropMeta[]): void;
+
 

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

@@ -1,9 +1,9 @@
 /**
-* web-c-runtime v0.1.1-beta.12
+* web-c-runtime v0.1.1-beta.14
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
-import { coerceCustomElementAttribute, findCustomElementPropByAttribute, getCustomElementAttributeName, getCustomElementObservedAttributes, reflectCustomElementProperty } from "@zeus-js/runtime-dom";
+import { coerceCustomElementAttribute, findCustomElementPropByAttribute, getCustomElementAttributeName, getCustomElementObservedAttributes, isWithinRuntimeDomMove, reflectCustomElementProperty } from "@zeus-js/runtime-dom";
 //#region packages/web-c/web-c-runtime/src/form-callbacks.ts
 function invokeFormCallback(hostRef, callback) {
 	switch (callback.type) {
@@ -37,10 +37,14 @@ function registerHost(host, meta) {
 		connected: false,
 		loaded: false,
 		values: /* @__PURE__ */ new Map(),
+		propDefinitions: [...meta.props],
 		attributeProps: /* @__PURE__ */ new Set(),
 		reflectingAttrs: /* @__PURE__ */ new Set(),
+		preUpgradeAttributes: /* @__PURE__ */ new Map(),
+		pendingAttributes: /* @__PURE__ */ new Map(),
 		pendingFormCallbacks: [],
-		readyWaiters: []
+		readyWaiters: [],
+		exposedMethods: Object.create(null)
 	};
 	hostRefs.set(host, hostRef);
 	return hostRef;
@@ -69,10 +73,12 @@ function installPropertyAccessors(proto, props) {
 		if (Object.getOwnPropertyDescriptor(proto, prop.name)) continue;
 		Object.defineProperty(proto, prop.name, {
 			get() {
-				return getPropValue(requireHostRef(this), prop);
+				const hostRef = requireHostRef(this);
+				return getPropValue(hostRef, findProp(hostRef, prop.name));
 			},
 			set(value) {
-				setPropValue(requireHostRef(this), prop, value);
+				const hostRef = requireHostRef(this);
+				setPropValue(hostRef, findProp(hostRef, prop.name), value);
 			},
 			configurable: true,
 			enumerable: true
@@ -85,36 +91,56 @@ function getPropValue(hostRef, prop) {
 }
 function setPropValue(hostRef, prop, value) {
 	const oldValue = getPropValue(hostRef, prop);
-	if (Object.is(oldValue, value)) return;
 	hostRef.values.set(prop.name, value);
 	hostRef.attributeProps.delete(prop.name);
+	hostRef.pendingAttributes.delete(prop.name);
 	if (prop.reflect) reflectCustomElementProperty(hostRef.host, prop, value, hostRef.reflectingAttrs);
-	if (hostRef.loaded) {
+	if (hostRef.loaded && !Object.is(oldValue, value)) {
 		var _hostRef$instance, _hostRef$instance$pro;
-		(_hostRef$instance = hostRef.instance) === null || _hostRef$instance === void 0 || (_hostRef$instance$pro = _hostRef$instance.propertyChanged) === null || _hostRef$instance$pro === void 0 || _hostRef$instance$pro.call(_hostRef$instance, prop.name, oldValue, value);
+		(_hostRef$instance = hostRef.instance) === null || _hostRef$instance === void 0 || (_hostRef$instance$pro = _hostRef$instance.propertyChanged) === null || _hostRef$instance$pro === void 0 || _hostRef$instance$pro.call(_hostRef$instance, {
+			name: prop.name,
+			value,
+			source: "property"
+		});
 	}
 }
-function syncAttributeToProperty(hostRef, attrName, _oldValue, newValue) {
+function syncAttributeToProperty(hostRef, attrName, oldValue, newValue) {
 	const normalizedAttrName = normalizeAttrName(attrName);
 	if (hostRef.reflectingAttrs.has(normalizedAttrName)) return;
-	const prop = findCustomElementPropByAttribute(hostRef.meta.props, normalizedAttrName);
+	const initialValue = hostRef.preUpgradeAttributes.get(normalizedAttrName);
+	hostRef.preUpgradeAttributes.delete(normalizedAttrName);
+	if (oldValue === null && newValue === initialValue) return;
+	const prop = findCustomElementPropByAttribute(hostRef.propDefinitions, normalizedAttrName);
 	if (!prop) return;
+	hostRef.attributeProps.add(prop.name);
+	if (prop.deserialize === true) {
+		hostRef.pendingAttributes.set(prop.name, newValue);
+		return;
+	}
 	const oldPropValue = getPropValue(hostRef, prop);
 	const newPropValue = coerceCustomElementAttribute(prop, newValue);
-	if (Object.is(oldPropValue, newPropValue)) return;
 	hostRef.values.set(prop.name, newPropValue);
-	hostRef.attributeProps.add(prop.name);
-	if (hostRef.loaded) {
+	if (hostRef.loaded && !Object.is(oldPropValue, newPropValue)) {
 		var _hostRef$instance2, _hostRef$instance2$pr;
-		(_hostRef$instance2 = hostRef.instance) === null || _hostRef$instance2 === void 0 || (_hostRef$instance2$pr = _hostRef$instance2.propertyChanged) === null || _hostRef$instance2$pr === void 0 || _hostRef$instance2$pr.call(_hostRef$instance2, prop.name, oldPropValue, newPropValue);
+		(_hostRef$instance2 = hostRef.instance) === null || _hostRef$instance2 === void 0 || (_hostRef$instance2$pr = _hostRef$instance2.propertyChanged) === null || _hostRef$instance2$pr === void 0 || _hostRef$instance2$pr.call(_hostRef$instance2, {
+			name: prop.name,
+			value: newPropValue,
+			source: "attribute",
+			rawAttributeValue: newValue
+		});
 	}
 }
 function applyInitialValues(hostRef) {
 	const host = hostRef.host;
-	for (const prop of hostRef.meta.props) {
+	for (const prop of hostRef.propDefinitions) {
 		if (hostRef.values.has(prop.name)) continue;
 		const attrName = getCustomElementAttributeName(prop);
 		if (attrName && host.hasAttribute(attrName)) {
+			if (prop.deserialize === true) {
+				hostRef.pendingAttributes.set(prop.name, host.getAttribute(attrName));
+				hostRef.attributeProps.add(prop.name);
+				continue;
+			}
 			hostRef.values.set(prop.name, coerceCustomElementAttribute(prop, host.getAttribute(attrName)));
 			hostRef.attributeProps.add(prop.name);
 			continue;
@@ -122,6 +148,20 @@ function applyInitialValues(hostRef) {
 		if ("default" in prop) hostRef.values.set(prop.name, prop.default);
 	}
 }
+/** Replace deferred codec markers with the implementation's real schema. */
+function resolveHostProperties(hostRef, definitions) {
+	for (const previous of hostRef.propDefinitions) {
+		if (!hostRef.pendingAttributes.has(previous.name)) continue;
+		const definition = definitions.find((prop) => prop.name === previous.name);
+		const attrName = definition && getCustomElementAttributeName(definition);
+		if (definition && attrName) hostRef.values.set(previous.name, coerceCustomElementAttribute(definition, hostRef.pendingAttributes.get(previous.name)));
+	}
+	hostRef.propDefinitions = definitions;
+	hostRef.pendingAttributes.clear();
+}
+function findProp(hostRef, name) {
+	return hostRef.propDefinitions.find((prop) => prop.name === name);
+}
 function getObservedAttributes(props) {
 	return getCustomElementObservedAttributes(props);
 }
@@ -139,6 +179,9 @@ function upgradePreDefinedProperties(host, hostRef) {
 		const descriptor = Object.getOwnPropertyDescriptor(target, prop.name);
 		if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.configurable) === false) continue;
 		const value = target[prop.name];
+		const attrName = getCustomElementAttributeName(prop);
+		const attrValue = attrName ? host.getAttribute(attrName) : null;
+		if (attrName && attrValue !== null) hostRef.preUpgradeAttributes.set(attrName, attrValue);
 		delete target[prop.name];
 		setPropValue(hostRef, prop, value);
 	}
@@ -177,6 +220,7 @@ function _asyncToGenerator(n) {
 const moduleCache = /* @__PURE__ */ new WeakMap();
 function waitForComponentReady(hostRef) {
 	if (hostRef.loaded) return Promise.resolve(hostRef.host);
+	if (hostRef.readinessError) return Promise.reject(hostRef.readinessError);
 	return new Promise((resolve, reject) => {
 		hostRef.readyWaiters.push({
 			resolve,
@@ -184,6 +228,11 @@ function waitForComponentReady(hostRef) {
 		});
 	});
 }
+function rejectComponentReady(hostRef, error) {
+	hostRef.readinessError = error;
+	for (const name of Object.keys(hostRef.exposedMethods)) delete hostRef.exposedMethods[name];
+	rejectReadyWaiters(hostRef, error);
+}
 function initializeComponent(_x) {
 	return _initializeComponent.apply(this, arguments);
 }
@@ -197,6 +246,7 @@ function _initializeComponent() {
 		}
 		if (hostRef.loading) {
 			yield hostRef.loading;
+			if (hostRef.connected && !hostRef.loaded) yield initializeComponent(hostRef);
 			return;
 		}
 		const loading = doInitializeComponent(hostRef);
@@ -204,7 +254,7 @@ function _initializeComponent() {
 		try {
 			yield loading;
 		} catch (error) {
-			rejectReadyWaiters(hostRef, error);
+			rejectComponentReady(hostRef, error instanceof Error ? error : new Error(String(error)));
 			throw error;
 		} finally {
 			if (hostRef.loading === loading) hostRef.loading = void 0;
@@ -309,16 +359,21 @@ function createLazyElementClass(meta) {
 		connectedCallback() {
 			const hostRef = requireHostRef(this);
 			hostRef.connected = true;
+			hostRef.readinessError = void 0;
 			initializeComponent(hostRef).catch((error) => {
 				reportInitializationError(meta.tagName, error);
 			});
 		}
 		disconnectedCallback() {
+			if (isWithinRuntimeDomMove(this)) return;
 			const hostRef = requireHostRef(this);
 			hostRef.connected = false;
-			if (hostRef.loaded) {
+			if (!hostRef.loaded) 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);
+			} finally {
+				for (const name of Object.keys(hostRef.exposedMethods)) delete hostRef.exposedMethods[name];
 			}
 		}
 		attributeChangedCallback(name, oldValue, newValue) {
@@ -378,7 +433,8 @@ function installMethodProxies(proto, methods) {
 				const args = Array.prototype.slice.call(arguments);
 				const hostRef = requireHostRef(host);
 				return waitForComponentReady(hostRef).then((readyHost) => {
-					const method = readyHost[name];
+					if (!hostRef.connected) throw new Error(`[ZEUS_WC_DISCONNECTED_BEFORE_READY] <${hostRef.meta.tagName}> is disconnected.`);
+					const method = hostRef.exposedMethods[name];
 					if (typeof method !== "function") throw new Error(`[zeus:web-c] Method "${name}" is not exposed on <${hostRef.meta.tagName}>.`);
 					return method.apply(readyHost, args);
 				});
@@ -388,15 +444,21 @@ function installMethodProxies(proto, methods) {
 }
 //#endregion
 //#region packages/web-c/web-c-runtime/src/bootstrapLazy.ts
+const definitions = /* @__PURE__ */ new WeakMap();
 function bootstrapLazy(components, options = {}) {
 	var _options$registry;
 	const registry = (_options$registry = options.registry) !== null && _options$registry !== void 0 ? _options$registry : typeof customElements === "undefined" ? void 0 : customElements;
 	if (!registry) return;
 	for (const meta of components) {
-		if (registry.get(meta.tagName)) continue;
+		const existing = registry.get(meta.tagName);
+		if (existing) {
+			if (definitions.get(existing) === meta) continue;
+			throw new Error(`[ZEUS_WC_DUPLICATE_TAG] <${meta.tagName}> is already registered with a different definition.`);
+		}
 		const LazyElement = createLazyElementClass(meta);
 		registry.define(meta.tagName, LazyElement);
+		definitions.set(LazyElement, meta);
 	}
 }
 //#endregion
-export { bootstrapLazy, createLazyElementClass };
+export { bootstrapLazy, createLazyElementClass, resolveHostProperties };

package/package.json

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