@zeus-js/web-c-runtime 0.1.0-canary.20260605.7.1.708d4580

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

@@ -0,0 +1,60 @@
+export type ZeusPropType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function' | 'unknown';
+export interface ZeusPropMeta {
+    name: string;
+    attrName?: string | false;
+    type: ZeusPropType;
+    reflect?: boolean;
+    default?: unknown;
+}
+export interface ZeusLazyComponentMeta {
+    tagName: string;
+    /**
+     * Real component implementation chunk.
+     * This function must be explicitly generated by the component library manifest,
+     * so the runtime does not need to construct dynamic paths.
+     */
+    load: () => Promise<ZeusComponentModule | {
+        default: ZeusComponentModule;
+    }>;
+    props: ZeusPropMeta[];
+    /**
+     * Whether to render into a ShadowRoot.
+     *
+     * @default false
+     */
+    shadow?: boolean;
+}
+export interface HostRef {
+    host: HTMLElement;
+    meta: ZeusLazyComponentMeta;
+    connected: boolean;
+    loaded: boolean;
+    loading?: Promise<void>;
+    instance?: ZeusComponentInstance;
+    values: Map<string, unknown>;
+    reflectingAttrs: Set<string>;
+    readyWaiters: Array<{
+        resolve(host: HTMLElement): void;
+        reject(error: unknown): void;
+    }>;
+}
+export interface ZeusComponentInstance {
+    connected?(): void;
+    disconnected?(): void;
+    propertyChanged?(name: string, oldValue: unknown, newValue: unknown): void;
+    /**
+     * Can return Node / Node[] / string.
+     * If the component completes rendering itself, it can also return void.
+     */
+    render?(): void | string | Node | Node[];
+    dispose?(): void;
+}
+export interface ZeusComponentModule {
+    createComponent(hostRef: HostRef): ZeusComponentInstance;
+}
+
+export declare function bootstrapLazy(components: ZeusLazyComponentMeta[]): void;
+
+export declare function createLazyElementClass(meta: ZeusLazyComponentMeta): CustomElementConstructor;
+
+

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

@@ -0,0 +1,357 @@
+/**
+* web-c-runtime v0.1.0-canary.20260605.7.1.708d4580
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+//#region packages/web-c/web-c-runtime/src/host-ref.ts
+const hostRefs = /* @__PURE__ */ new WeakMap();
+function registerHost(host, meta) {
+	const existing = hostRefs.get(host);
+	if (existing) return existing;
+	const hostRef = {
+		host,
+		meta,
+		connected: false,
+		loaded: false,
+		values: /* @__PURE__ */ new Map(),
+		reflectingAttrs: /* @__PURE__ */ new Set(),
+		readyWaiters: []
+	};
+	hostRefs.set(host, hostRef);
+	return hostRef;
+}
+function getHostRef(host) {
+	return hostRefs.get(host);
+}
+function requireHostRef(host) {
+	const hostRef = getHostRef(host);
+	if (!hostRef) throw new Error(`[zeus:web-c] hostRef not found for <${host.tagName.toLowerCase()}>.`);
+	return hostRef;
+}
+//#endregion
+//#region packages/web-c/web-c-runtime/src/props.ts
+function installPropertyAccessors(proto, props) {
+	for (const prop of props) {
+		if (Object.getOwnPropertyDescriptor(proto, prop.name)) continue;
+		Object.defineProperty(proto, prop.name, {
+			get() {
+				return getPropValue(requireHostRef(this), prop);
+			},
+			set(value) {
+				setPropValue(requireHostRef(this), prop, value);
+			},
+			configurable: true,
+			enumerable: true
+		});
+	}
+}
+function getPropValue(hostRef, prop) {
+	if (hostRef.values.has(prop.name)) return hostRef.values.get(prop.name);
+	return prop.default;
+}
+function setPropValue(hostRef, prop, value) {
+	const oldValue = getPropValue(hostRef, prop);
+	if (Object.is(oldValue, value)) return;
+	hostRef.values.set(prop.name, value);
+	if (prop.reflect) reflectPropertyToAttribute(hostRef, prop, value);
+	if (hostRef.loaded) {
+		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);
+	}
+}
+function syncAttributeToProperty(hostRef, attrName, _oldValue, newValue) {
+	const normalizedAttrName = normalizeAttrName(attrName);
+	if (hostRef.reflectingAttrs.has(normalizedAttrName)) return;
+	const prop = findPropByAttrName(hostRef, normalizedAttrName);
+	if (!prop) return;
+	const oldPropValue = getPropValue(hostRef, prop);
+	const newPropValue = parseAttributeValue(prop, newValue);
+	if (Object.is(oldPropValue, newPropValue)) return;
+	hostRef.values.set(prop.name, newPropValue);
+	if (hostRef.loaded) {
+		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);
+	}
+}
+function applyInitialValues(hostRef) {
+	const host = hostRef.host;
+	for (const prop of hostRef.meta.props) {
+		if (hostRef.values.has(prop.name)) continue;
+		const attrName = getAttrName(prop);
+		if (attrName && host.hasAttribute(attrName)) {
+			hostRef.values.set(prop.name, parseAttributeValue(prop, host.getAttribute(attrName)));
+			continue;
+		}
+		if ("default" in prop) hostRef.values.set(prop.name, prop.default);
+	}
+}
+function getObservedAttributes(props) {
+	const attrs = [];
+	for (const prop of props) {
+		const attrName = getAttrName(prop);
+		if (attrName) attrs.push(attrName);
+	}
+	return attrs;
+}
+/**
+* Upgrades properties that were written on an element instance before its
+* custom element class was defined (e.g. during SSR or before
+* `defineCustomElements()` was called). Own properties on the element
+* shadow the prototype accessors, so we must capture them before
+* the prototype accessors take effect.
+*/
+function upgradePreDefinedProperties(host, hostRef) {
+	const target = host;
+	for (const prop of hostRef.meta.props) {
+		if (!Object.prototype.hasOwnProperty.call(target, prop.name)) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(target, prop.name);
+		if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.configurable) === false) continue;
+		const value = target[prop.name];
+		delete target[prop.name];
+		setPropValue(hostRef, prop, value);
+	}
+}
+function findPropByAttrName(hostRef, attrName) {
+	return hostRef.meta.props.find((prop) => {
+		return getAttrName(prop) === attrName;
+	});
+}
+function getAttrName(prop) {
+	var _prop$attrName;
+	if (prop.attrName === false) return;
+	if (!isAttributeBackedType(prop.type)) return;
+	return normalizeAttrName((_prop$attrName = prop.attrName) !== null && _prop$attrName !== void 0 ? _prop$attrName : toKebabCase(prop.name));
+}
+function isAttributeBackedType(type) {
+	return type === "string" || type === "number" || type === "boolean";
+}
+function normalizeAttrName(value) {
+	return value.toLowerCase();
+}
+function parseAttributeValue(prop, value) {
+	switch (prop.type) {
+		case "boolean": return value !== null;
+		case "number":
+			if (value === null) return;
+			return Number(value);
+		case "string": return value !== null && value !== void 0 ? value : void 0;
+		default: return value;
+	}
+}
+function reflectPropertyToAttribute(hostRef, prop, value) {
+	const host = hostRef.host;
+	const attrName = getAttrName(prop);
+	if (!attrName) return;
+	hostRef.reflectingAttrs.add(attrName);
+	try {
+		if (prop.type === "boolean") {
+			host.toggleAttribute(attrName, Boolean(value));
+			return;
+		}
+		if (value === null || value === void 0 || value === false) {
+			host.removeAttribute(attrName);
+			return;
+		}
+		if (prop.type === "string" || prop.type === "number") host.setAttribute(attrName, String(value));
+	} finally {
+		hostRef.reflectingAttrs.delete(attrName);
+	}
+}
+function toKebabCase(value) {
+	return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/asyncToGenerator.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+	try {
+		var i = n[a](c), u = i.value;
+	} catch (n) {
+		e(n);
+		return;
+	}
+	i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+	return function() {
+		var t = this, e = arguments;
+		return new Promise(function(r, o) {
+			var a = n.apply(t, e);
+			function _next(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+			}
+			function _throw(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+			}
+			_next(void 0);
+		});
+	};
+}
+//#endregion
+//#region packages/web-c/web-c-runtime/src/lifecycle.ts
+const moduleCache = /* @__PURE__ */ new WeakMap();
+function waitForComponentReady(hostRef) {
+	if (hostRef.loaded) return Promise.resolve(hostRef.host);
+	return new Promise((resolve, reject) => {
+		hostRef.readyWaiters.push({
+			resolve,
+			reject
+		});
+	});
+}
+function initializeComponent(_x) {
+	return _initializeComponent.apply(this, arguments);
+}
+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);
+			return;
+		}
+		if (hostRef.loading) {
+			yield hostRef.loading;
+			return;
+		}
+		const loading = doInitializeComponent(hostRef);
+		hostRef.loading = loading;
+		try {
+			yield loading;
+		} catch (error) {
+			rejectReadyWaiters(hostRef, error);
+			throw error;
+		} finally {
+			if (hostRef.loading === loading) hostRef.loading = void 0;
+		}
+	});
+	return _initializeComponent.apply(this, arguments);
+}
+function doInitializeComponent(_x2) {
+	return _doInitializeComponent.apply(this, arguments);
+}
+function _doInitializeComponent() {
+	_doInitializeComponent = _asyncToGenerator(function* (hostRef) {
+		applyInitialValues(hostRef);
+		const mod = yield loadComponentModule(hostRef);
+		if (!hostRef.connected) return;
+		const instance = mod.createComponent(hostRef);
+		hostRef.instance = instance;
+		try {
+			var _instance$connected, _instance$render;
+			(_instance$connected = instance.connected) === null || _instance$connected === void 0 || _instance$connected.call(instance);
+			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;
+			hostRef.loaded = false;
+			(_instance$dispose = instance.dispose) === null || _instance$dispose === void 0 || _instance$dispose.call(instance);
+			throw error;
+		}
+	});
+	return _doInitializeComponent.apply(this, arguments);
+}
+function loadComponentModule(_x3) {
+	return _loadComponentModule.apply(this, arguments);
+}
+function _loadComponentModule() {
+	_loadComponentModule = _asyncToGenerator(function* (hostRef) {
+		let pending = moduleCache.get(hostRef.meta);
+		if (!pending) {
+			pending = hostRef.meta.load().then((mod) => {
+				return "default" in mod ? mod.default : mod;
+			}).catch((error) => {
+				moduleCache.delete(hostRef.meta);
+				throw error;
+			});
+			moduleCache.set(hostRef.meta, pending);
+		}
+		return pending;
+	});
+	return _loadComponentModule.apply(this, arguments);
+}
+function resolveReadyWaiters(hostRef) {
+	const waiters = hostRef.readyWaiters.splice(0);
+	for (const waiter of waiters) waiter.resolve(hostRef.host);
+}
+function rejectReadyWaiters(hostRef, error) {
+	const waiters = hostRef.readyWaiters.splice(0);
+	for (const waiter of waiters) waiter.reject(error);
+}
+function mountRenderedOutput(hostRef, rendered) {
+	const root = getRenderRoot(hostRef);
+	if (typeof rendered === "string") {
+		root.innerHTML = rendered;
+		return;
+	}
+	if (Array.isArray(rendered)) {
+		root.replaceChildren(...rendered);
+		return;
+	}
+	root.replaceChildren(rendered);
+}
+function getRenderRoot(hostRef) {
+	var _hostRef$host$shadowR;
+	if (!hostRef.meta.shadow) return hostRef.host;
+	return (_hostRef$host$shadowR = hostRef.host.shadowRoot) !== null && _hostRef$host$shadowR !== void 0 ? _hostRef$host$shadowR : hostRef.host.attachShadow({ mode: "open" });
+}
+//#endregion
+//#region packages/web-c/web-c-runtime/src/lazy-element.ts
+function reportInitializationError(tagName, error) {
+	console.error(`[zeus:web-c] Failed to initialize <${tagName}>.`, error);
+}
+function createLazyElementClass(meta) {
+	const observedAttributes = getObservedAttributes(meta.props);
+	class ZeusLazyElement extends HTMLElement {
+		static get observedAttributes() {
+			return observedAttributes;
+		}
+		constructor() {
+			super();
+			const hostRef = registerHost(this, meta);
+			upgradePreDefinedProperties(this, hostRef);
+		}
+		connectedCallback() {
+			const hostRef = requireHostRef(this);
+			hostRef.connected = true;
+			initializeComponent(hostRef).catch((error) => {
+				reportInitializationError(meta.tagName, error);
+			});
+		}
+		disconnectedCallback() {
+			const hostRef = requireHostRef(this);
+			hostRef.connected = false;
+			if (hostRef.loaded) {
+				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);
+			}
+		}
+		attributeChangedCallback(name, oldValue, newValue) {
+			if (oldValue === newValue) return;
+			syncAttributeToProperty(requireHostRef(this), name, oldValue, newValue);
+		}
+		componentOnReady() {
+			const hostRef = requireHostRef(this);
+			if (hostRef.connected && !hostRef.loaded && !hostRef.loading) initializeComponent(hostRef).catch((error) => {
+				reportInitializationError(meta.tagName, error);
+			});
+			return waitForComponentReady(hostRef);
+		}
+	}
+	installPropertyAccessors(ZeusLazyElement.prototype, meta.props);
+	return ZeusLazyElement;
+}
+//#endregion
+//#region packages/web-c/web-c-runtime/src/bootstrapLazy.ts
+function bootstrapLazy(components) {
+	const registry = typeof customElements === "undefined" ? void 0 : customElements;
+	if (!registry) return;
+	for (const meta of components) {
+		if (registry.get(meta.tagName)) continue;
+		const LazyElement = createLazyElementClass(meta);
+		registry.define(meta.tagName, LazyElement);
+	}
+}
+//#endregion
+export { bootstrapLazy, createLazyElementClass };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@zeus-js/web-c-runtime",
+  "version": "0.1.0-canary.20260605.7.1.708d4580",
+  "description": "Zeus Web-C lazy-loading runtime",
+  "type": "module",
+  "main": "./dist/web-c-runtime.esm-bundler.js",
+  "module": "./dist/web-c-runtime.esm-bundler.js",
+  "types": "./dist/web-c-runtime.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/web-c-runtime.d.ts",
+      "import": "./dist/web-c-runtime.esm-bundler.js",
+      "module": "./dist/web-c-runtime.esm-bundler.js",
+      "default": "./dist/web-c-runtime.esm-bundler.js"
+    }
+  },
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baicie/zeus"
+  },
+  "buildOptions": {
+    "name": "ZeusWebCRuntime",
+    "formats": [
+      "esm-bundler"
+    ]
+  },
+  "keywords": [
+    "zeus",
+    "web-components",
+    "custom-elements"
+  ],
+  "author": "Baicie",
+  "license": "MIT"
+}