@sigx/runtime-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1123 @@
+import { detectAccess, effect, effectScope, signal, signal as signal$1, untrack, watch } from "@sigx/reactivity";
+
+//#region src/platform.ts
+let platformSyncProcessor = null;
+/**
+* Set the platform-specific sync processor for intrinsic elements.
+* Called by runtime-dom to handle checkbox/radio/select sync bindings.
+*/
+function setPlatformSyncProcessor(fn) {
+	platformSyncProcessor = fn;
+}
+/**
+* Get the current platform sync processor (for internal use).
+*/
+function getPlatformSyncProcessor() {
+	return platformSyncProcessor;
+}
+
+//#endregion
+//#region src/plugins.ts
+const plugins = [];
+function registerComponentPlugin(plugin) {
+	plugins.push(plugin);
+}
+/**
+* Get all registered plugins (internal use)
+*/
+function getComponentPlugins() {
+	return plugins;
+}
+
+//#endregion
+//#region src/app.ts
+const isDev = typeof process !== "undefined" && true || true;
+/**
+* Unique symbol for app context injection
+*/
+const AppContextKey = Symbol("sigx:app");
+let defaultMountFn = null;
+/**
+* Set the default mount function for the platform.
+* Called by platform packages (runtime-dom, runtime-terminal) on import.
+* 
+* @example
+* ```typescript
+* // In @sigx/runtime-dom
+* import { setDefaultMount } from '@sigx/runtime-core';
+* setDefaultMount(domMount);
+* ```
+*/
+function setDefaultMount(mountFn) {
+	defaultMountFn = mountFn;
+}
+/**
+* Get the current default mount function.
+* @internal
+*/
+function getDefaultMount() {
+	return defaultMountFn;
+}
+/**
+* Create an application instance.
+* 
+* @example
+* ```tsx
+* import { defineApp, defineInjectable } from '@sigx/runtime-core';
+* import { render } from '@sigx/runtime-dom';
+* 
+* // Define an injectable service
+* const useApiConfig = defineInjectable(() => ({ baseUrl: 'https://api.example.com' }));
+* 
+* const app = defineApp(<App />);
+* 
+* app.use(myPlugin, { option: 'value' });
+* 
+* // Provide using the injectable token (works with inject())
+* app.provide(useApiConfig, { baseUrl: 'https://custom.api.com' });
+* 
+* app.mount(document.getElementById('app')!, render);
+* ```
+*/
+function defineApp(rootComponent) {
+	const installedPlugins = /* @__PURE__ */ new Set();
+	const context = {
+		app: null,
+		provides: /* @__PURE__ */ new Map(),
+		config: {},
+		hooks: []
+	};
+	let isMounted = false;
+	let container = null;
+	let unmountFn = null;
+	const app = {
+		config: context.config,
+		use(plugin, options) {
+			if (installedPlugins.has(plugin)) {
+				if (isDev) console.warn(`Plugin ${plugin.name || "anonymous"} is already installed.`);
+				return app;
+			}
+			installedPlugins.add(plugin);
+			if (typeof plugin === "function") plugin(app, options);
+			else if (plugin && typeof plugin.install === "function") plugin.install(app, options);
+			else if (isDev) console.warn("Invalid plugin: must be a function or have an install() method.");
+			return app;
+		},
+		provide(token, value) {
+			const actualToken = token?._token ?? token;
+			if (isDev && context.provides.has(actualToken)) console.warn(`App-level provide: token is being overwritten.`);
+			context.provides.set(actualToken, value);
+			return app;
+		},
+		hook(hooks) {
+			context.hooks.push(hooks);
+			return app;
+		},
+		mount(target, renderFn) {
+			if (isMounted) {
+				if (isDev) console.warn("App is already mounted. Call app.unmount() first.");
+				return app;
+			}
+			const mountFn = renderFn ?? defaultMountFn;
+			if (!mountFn) throw new Error("No mount function provided and no default mount function set. Either pass a mount function to app.mount(), or import a platform package (e.g., @sigx/runtime-dom or @sigx/runtime-terminal) that sets the default.");
+			container = target;
+			isMounted = true;
+			const result = mountFn(rootComponent, target, context);
+			if (typeof result === "function") unmountFn = result;
+			return app;
+		},
+		unmount() {
+			if (!isMounted) {
+				if (isDev) console.warn("App is not mounted.");
+				return;
+			}
+			if (unmountFn) unmountFn();
+			context.provides.clear();
+			isMounted = false;
+			container = null;
+		},
+		get _context() {
+			return context;
+		},
+		get _isMounted() {
+			return isMounted;
+		},
+		get _container() {
+			return container;
+		}
+	};
+	context.app = app;
+	return app;
+}
+/**
+* Notify all app hooks that a component was created.
+* Called by the renderer after setup() returns.
+*/
+function notifyComponentCreated(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentCreated?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentCreated");
+	}
+}
+/**
+* Notify all app hooks that a component was mounted.
+* Called by the renderer after mount hooks run.
+*/
+function notifyComponentMounted(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentMounted?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentMounted");
+	}
+}
+/**
+* Notify all app hooks that a component was unmounted.
+* Called by the renderer before cleanup.
+*/
+function notifyComponentUnmounted(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentUnmounted?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentUnmounted");
+	}
+}
+/**
+* Notify all app hooks that a component updated.
+* Called by the renderer after re-render.
+*/
+function notifyComponentUpdated(context, instance) {
+	if (!context) return;
+	for (const hooks of context.hooks) try {
+		hooks.onComponentUpdated?.(instance);
+	} catch (err) {
+		handleHookError(context, err, instance, "onComponentUpdated");
+	}
+}
+/**
+* Handle an error in a component. Returns true if the error was handled.
+* Called by the renderer when an error occurs in setup or render.
+*/
+function handleComponentError(context, err, instance, info) {
+	if (!context) return false;
+	for (const hooks of context.hooks) try {
+		if (hooks.onComponentError?.(err, instance, info) === true) return true;
+	} catch (hookErr) {
+		console.error("Error in onComponentError hook:", hookErr);
+	}
+	if (context.config.errorHandler) try {
+		if (context.config.errorHandler(err, instance, info) === true) return true;
+	} catch (handlerErr) {
+		console.error("Error in app.config.errorHandler:", handlerErr);
+	}
+	return false;
+}
+/**
+* Handle errors that occur in hooks themselves
+*/
+function handleHookError(context, err, instance, hookName) {
+	console.error(`Error in ${hookName} hook:`, err);
+	if (context.config.errorHandler) try {
+		context.config.errorHandler(err, instance, `plugin hook: ${hookName}`);
+	} catch {}
+}
+
+//#endregion
+//#region src/component.ts
+let currentComponentContext = null;
+function getCurrentInstance() {
+	return currentComponentContext;
+}
+function setCurrentInstance(ctx) {
+	const prev = currentComponentContext;
+	currentComponentContext = ctx;
+	return prev;
+}
+function onMount(fn) {
+	if (currentComponentContext) currentComponentContext.onMount(fn);
+	else console.warn("onMount called outside of component setup");
+}
+function onCleanup(fn) {
+	if (currentComponentContext) currentComponentContext.onCleanup(fn);
+	else console.warn("onCleanup called outside of component setup");
+}
+const componentRegistry = /* @__PURE__ */ new Map();
+/**
+* Get component metadata (for DevTools)
+*/
+function getComponentMeta(factory) {
+	return componentRegistry.get(factory);
+}
+/**
+* Helper to create a proxy that tracks property access
+*/
+function createPropsProxy(target, onAccess) {
+	return new Proxy(target, { get(obj, prop) {
+		if (typeof prop === "string" && onAccess) onAccess(prop);
+		return obj[prop];
+	} });
+}
+/**
+* Define a component. Returns a JSX factory function.
+* 
+* @param setup - Setup function that receives context and returns a render function
+* @param options - Optional configuration (e.g., name for DevTools)
+* 
+* @example
+* ```tsx
+* type CardProps = DefineProp<"title", string> & DefineSlot<"header">;
+* 
+* export const Card = defineComponent<CardProps>((ctx) => {
+*     const { title } = ctx.props;
+*     const { slots } = ctx;
+*     
+*     return () => (
+*         <div class="card">
+*             {slots.header?.() ?? <h2>{title}</h2>}
+*             {slots.default()}
+*         </div>
+*     );
+* });
+* ```
+*/
+function defineComponent(setup, options) {
+	const factory = function(props) {
+		return {
+			type: factory,
+			props: props || {},
+			key: props?.key || null,
+			children: [],
+			dom: null
+		};
+	};
+	factory.__setup = setup;
+	factory.__name = options?.name;
+	factory.__props = null;
+	factory.__events = null;
+	factory.__ref = null;
+	factory.__slots = null;
+	componentRegistry.set(factory, {
+		name: options?.name,
+		setup
+	});
+	getComponentPlugins().forEach((p) => p.onDefine?.(options?.name, factory, setup));
+	return factory;
+}
+
+//#endregion
+//#region src/jsx-runtime.ts
+const Fragment = Symbol.for("sigx.Fragment");
+const Text = Symbol.for("sigx.Text");
+function normalizeChildren(children) {
+	if (children == null || children === false || children === true) return [];
+	if (Array.isArray(children)) return children.flatMap((c) => normalizeChildren(c));
+	if (typeof children === "string" || typeof children === "number") return [{
+		type: Text,
+		props: {},
+		key: null,
+		children: [],
+		dom: null,
+		text: children
+	}];
+	if (children.type) return [children];
+	return [];
+}
+/**
+* Check if a type is a sigx component (has __setup)
+*/
+function isComponent$1(type) {
+	return typeof type === "function" && "__setup" in type;
+}
+/**
+* Create a JSX element - this is the core function called by TSX transpilation
+*/
+function jsx(type, props, key) {
+	const processedProps = { ...props || {} };
+	if (props) {
+		for (const propKey in props) if (propKey === "sync") {
+			let syncBinding = props[propKey];
+			if (typeof syncBinding === "function") {
+				const detected = detectAccess(syncBinding);
+				if (detected) syncBinding = detected;
+			}
+			if (Array.isArray(syncBinding) && syncBinding.length === 2) {
+				const [stateObj, key$1] = syncBinding;
+				let handled = false;
+				const platformProcessor = getPlatformSyncProcessor();
+				if (typeof type === "string" && platformProcessor) handled = platformProcessor(type, processedProps, [stateObj, key$1], props);
+				if (!handled) {
+					processedProps.value = stateObj[key$1];
+					const existingHandler = processedProps["onUpdate:value"];
+					processedProps["onUpdate:value"] = (v) => {
+						stateObj[key$1] = v;
+						if (existingHandler) existingHandler(v);
+					};
+				}
+				delete processedProps.sync;
+			}
+		} else if (propKey.startsWith("sync:")) {
+			const syncBinding = props[propKey];
+			if (Array.isArray(syncBinding) && syncBinding.length === 2) {
+				const [stateObj, key$1] = syncBinding;
+				const name = propKey.slice(5);
+				processedProps[name] = stateObj[key$1];
+				const eventName = `onUpdate:${name}`;
+				const existingHandler = processedProps[eventName];
+				processedProps[eventName] = (v) => {
+					stateObj[key$1] = v;
+					if (existingHandler) existingHandler(v);
+				};
+				delete processedProps[propKey];
+			}
+		}
+	}
+	if (isComponent$1(type)) {
+		const { children: children$1, ...rest$1 } = processedProps;
+		return {
+			type,
+			props: {
+				...rest$1,
+				children: children$1
+			},
+			key: key || rest$1.key || null,
+			children: [],
+			dom: null
+		};
+	}
+	if (typeof type === "function" && type !== Fragment) return type(processedProps);
+	const { children, ...rest } = processedProps;
+	return {
+		type,
+		props: rest,
+		key: key || rest.key || null,
+		children: normalizeChildren(children),
+		dom: null
+	};
+}
+/**
+* JSX Factory for fragments
+*/
+function jsxs(type, props, key) {
+	return jsx(type, props, key);
+}
+const jsxDEV = jsx;
+
+//#endregion
+//#region src/utils/index.ts
+var Utils = class {
+	static isPromise(value) {
+		return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+	}
+};
+function guid$1() {
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+		var r = Math.random() * 16 | 0;
+		return (c == "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+
+//#endregion
+//#region src/models/index.ts
+const guid = guid$1;
+let InstanceLifetimes = /* @__PURE__ */ function(InstanceLifetimes$1) {
+	InstanceLifetimes$1[InstanceLifetimes$1["Transient"] = 0] = "Transient";
+	InstanceLifetimes$1[InstanceLifetimes$1["Scoped"] = 1] = "Scoped";
+	InstanceLifetimes$1[InstanceLifetimes$1["Singleton"] = 2] = "Singleton";
+	return InstanceLifetimes$1;
+}({});
+function valueOf(obj) {
+	return obj;
+}
+
+//#endregion
+//#region src/messaging/index.ts
+function createTopic(options) {
+	let subscribers = [];
+	const publish = (data) => {
+		subscribers.forEach((s) => s(data));
+	};
+	const subscribe = (handler) => {
+		subscribers.push(handler);
+		const unsubscribe = () => {
+			const idx = subscribers.indexOf(handler);
+			if (idx > -1) subscribers.splice(idx, 1);
+		};
+		try {
+			onCleanup(unsubscribe);
+		} catch (e) {}
+		return { unsubscribe };
+	};
+	const destroy = () => {
+		subscribers = [];
+	};
+	return {
+		publish,
+		subscribe,
+		destroy
+	};
+}
+function toSubscriber(topic) {
+	return { subscribe: (handler) => topic.subscribe(handler) };
+}
+
+//#endregion
+//#region src/di/injectable.ts
+function inject(token) {
+	const ctx = getCurrentInstance();
+	if (!ctx) return void 0;
+	let current = ctx;
+	while (current) {
+		if (current.provides && current.provides.has(token)) return current.provides.get(token);
+		current = current.parent;
+	}
+	const appContext = getAppContext(ctx);
+	if (appContext && appContext.provides.has(token)) return appContext.provides.get(token);
+}
+/**
+* Get the app context from the current component context
+*/
+function getAppContext(ctx) {
+	let current = ctx;
+	while (current) {
+		if (current._appContext) return current._appContext;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Inject the App instance (useful for plugins)
+*/
+function injectApp() {
+	return inject(AppContextKey);
+}
+function provide(token, value) {
+	const ctx = getCurrentInstance();
+	if (!ctx) {
+		console.warn("provide called outside of component setup");
+		return;
+	}
+	if (!ctx.provides) ctx.provides = /* @__PURE__ */ new Map();
+	ctx.provides.set(token, value);
+}
+const globalInstances = /* @__PURE__ */ new Map();
+function defineInjectable(factory) {
+	const token = factory;
+	const useFn = () => {
+		const injected = inject(token);
+		if (injected) return injected;
+		if (!globalInstances.has(token)) globalInstances.set(token, factory());
+		return globalInstances.get(token);
+	};
+	useFn._factory = factory;
+	useFn._token = token;
+	return useFn;
+}
+function defineProvide(useFn) {
+	const factory = useFn._factory;
+	const token = useFn._token;
+	if (!factory || !token) throw new Error("defineProvide must be called with a function created by defineInjectable");
+	const instance = factory();
+	provide(token, instance);
+	return instance;
+}
+
+//#endregion
+//#region src/di/factory.ts
+var SubscriptionHandler = class {
+	unsubs = [];
+	add(unsub) {
+		this.unsubs.push(unsub);
+	}
+	unsubscribe() {
+		this.unsubs.forEach((u) => u());
+		this.unsubs = [];
+	}
+};
+function defineFactory(setup, lifetime, typeIdentifier) {
+	const factoryCreator = (...args) => {
+		const subscriptions = new SubscriptionHandler();
+		const deactivations = /* @__PURE__ */ new Set();
+		let customDispose = null;
+		const result = setup({
+			onDeactivated: (fn) => deactivations.add(fn),
+			subscriptions,
+			overrideDispose: (fn) => customDispose = fn
+		}, ...args);
+		const dispose = () => {
+			deactivations.forEach((d) => d());
+			subscriptions.unsubscribe();
+			result.dispose?.();
+		};
+		if (customDispose) customDispose(dispose);
+		else try {
+			onCleanup(() => dispose());
+		} catch (e) {}
+		return {
+			...result,
+			dispose
+		};
+	};
+	if (setup.length <= 1) return defineInjectable(() => factoryCreator());
+	return factoryCreator;
+}
+
+//#endregion
+//#region src/stores/store.ts
+function defineStore(name, setup, lifetime = InstanceLifetimes.Scoped) {
+	return defineFactory((ctxFactory, ...args) => {
+		const scope = effectScope(true);
+		let messages = [];
+		const id = `${name}_${guid()}`;
+		const result = setup({
+			...ctxFactory,
+			defineState: (state) => {
+				return defineState(state, id, scope, messages);
+			},
+			defineActions: (actions) => {
+				return defineActions(actions, id, messages);
+			}
+		}, ...args);
+		ctxFactory.onDeactivated(() => {
+			scope.stop();
+			messages?.forEach((m) => m.destroy());
+			messages = null;
+		});
+		if (!result.name) result.name = id;
+		return result;
+	}, lifetime);
+}
+function defineActions(actions, storeInstanceName, messages) {
+	const events = {};
+	const namespace = `${storeInstanceName}.actions.${guid()}`;
+	const onDispatching = {};
+	const onDispatched = {};
+	const onFailure = {};
+	const result = {
+		onDispatching,
+		onDispatched,
+		onFailure
+	};
+	function getEvent(actionName, type) {
+		const name = `${actionName}.${type}`;
+		if (!events[name]) {
+			events[name] = createTopic({
+				namespace,
+				name
+			});
+			messages.push(events[name]);
+		}
+		return events[name];
+	}
+	Object.keys(actions).forEach((actionName) => {
+		onDispatching[actionName] = { subscribe: (fn) => {
+			return getEvent(actionName, "onDispatching").subscribe(function() {
+				fn.apply(this, arguments[0]);
+			});
+		} };
+		onDispatched[actionName] = { subscribe: (fn) => {
+			return getEvent(actionName, "onDispatched").subscribe(function() {
+				const msg = arguments[0];
+				const allArguments = [msg.result].concat(Array.from(msg.args));
+				fn.apply(this, allArguments);
+			});
+		} };
+		onFailure[actionName] = { subscribe: (fn) => {
+			return getEvent(actionName, "onFailure").subscribe(function() {
+				const msg = arguments[0];
+				const allArguments = [msg.reason].concat(Array.from(msg.args));
+				fn.apply(this, allArguments);
+			});
+		} };
+		result[actionName] = function() {
+			try {
+				const currentArguments = arguments;
+				getEvent(actionName, "onDispatching").publish(currentArguments);
+				const returnedResult = actions[actionName].apply(this, currentArguments);
+				if (Utils.isPromise(returnedResult)) returnedResult.then((result$1) => {
+					getEvent(actionName, "onDispatched").publish({
+						result: returnedResult,
+						args: currentArguments
+					});
+				});
+				else getEvent(actionName, "onDispatched").publish({
+					result: returnedResult,
+					args: currentArguments
+				});
+				return returnedResult;
+			} catch (err) {
+				console.error(err);
+				getEvent(actionName, "onFailure").publish({
+					reason: err,
+					args: arguments
+				});
+			}
+		};
+	});
+	return result;
+}
+function defineState(value, storeInstanceName, scope, messages) {
+	const state = signal$1(value);
+	const events = {};
+	const mutate = {};
+	function initProperty(key) {
+		scope.run(() => {
+			watch(() => state[key], (newValue) => {
+				triggerEvent(key, newValue);
+			}, {
+				deep: true,
+				immediate: true
+			});
+		});
+		mutate[key] = (val) => {
+			try {
+				let newValue;
+				if (typeof val === "function") newValue = val(state[key]);
+				else newValue = val;
+				state[key] = newValue;
+			} catch (err) {
+				console.error(err);
+			}
+		};
+		const eventKey = `onMutated${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+		if (!events[eventKey]) {
+			const topic = createTopic({
+				namespace: `${storeInstanceName}.events`,
+				name: eventKey
+			});
+			events[eventKey] = topic;
+			messages.push(topic);
+		}
+	}
+	function triggerEvent(name, value$1) {
+		const keyString = name;
+		events[`onMutated${keyString.charAt(0).toUpperCase()}${keyString.slice(1)}`]?.publish(value$1);
+	}
+	if (value) Object.keys(value).forEach((key) => {
+		initProperty(key);
+	});
+	return {
+		state,
+		events,
+		mutate
+	};
+}
+
+//#endregion
+//#region src/renderer.ts
+/**
+* Check if a vnode type is a component (has __setup)
+*/
+function isComponent(type) {
+	return typeof type === "function" && "__setup" in type;
+}
+function createRenderer(options) {
+	const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options;
+	let isPatching = false;
+	let currentAppContext = null;
+	function render(element, container, appContext) {
+		if (appContext) currentAppContext = appContext;
+		const oldVNode = container._vnode;
+		let vnode = null;
+		if (element != null && element !== false && element !== true) if (typeof element === "string" || typeof element === "number") vnode = {
+			type: Text,
+			props: {},
+			key: null,
+			children: [],
+			dom: null,
+			text: element
+		};
+		else vnode = element;
+		if (vnode) {
+			if (oldVNode) patch(oldVNode, vnode, container);
+			else mount(vnode, container);
+			container._vnode = vnode;
+		} else if (oldVNode) {
+			unmount(oldVNode, container);
+			container._vnode = null;
+		}
+	}
+	function mount(vnode, container, before = null) {
+		if (vnode.type === Text) {
+			const node = hostCreateText(String(vnode.text));
+			vnode.dom = node;
+			node.__vnode = vnode;
+			hostInsert(node, container, before);
+			return;
+		}
+		if (vnode.type === Fragment) {
+			const anchor = hostCreateComment("");
+			vnode.dom = anchor;
+			hostInsert(anchor, container, before);
+			vnode.children.forEach((child) => mount(child, container, anchor));
+			return;
+		}
+		if (isComponent(vnode.type)) {
+			mountComponent(vnode, container, before, vnode.type.__setup);
+			return;
+		}
+		const element = hostCreateElement(vnode.type);
+		vnode.dom = element;
+		element.__vnode = vnode;
+		if (vnode.props) {
+			for (const key in vnode.props) if (key !== "children" && key !== "key" && key !== "ref") hostPatchProp(element, key, null, vnode.props[key]);
+		}
+		if (vnode.props.ref) {
+			if (typeof vnode.props.ref === "function") vnode.props.ref(element);
+			else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = element;
+		}
+		vnode.children.forEach((child) => {
+			child.parent = vnode;
+			mount(child, element);
+		});
+		hostInsert(element, container, before);
+	}
+	function unmount(vnode, container) {
+		if (vnode._effect) vnode._effect();
+		if (vnode.cleanup) vnode.cleanup();
+		if (isComponent(vnode.type)) {
+			const subTree = vnode._subTree;
+			if (subTree) unmount(subTree, container);
+			if (vnode.dom) hostRemove(vnode.dom);
+			if (vnode.props?.ref) {
+				if (typeof vnode.props.ref === "function") vnode.props.ref(null);
+				else if (typeof vnode.props.ref === "object") vnode.props.ref.current = null;
+			}
+			return;
+		}
+		if (vnode.type === Fragment) {
+			vnode.children.forEach((child) => unmount(child, container));
+			if (vnode.dom) hostRemove(vnode.dom);
+			return;
+		}
+		if (vnode.props?.ref) {
+			if (typeof vnode.props.ref === "function") vnode.props.ref(null);
+			else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = null;
+		}
+		if (vnode.children && vnode.children.length > 0) vnode.children.forEach((child) => unmount(child, vnode.dom));
+		if (vnode.dom) hostRemove(vnode.dom);
+	}
+	function patch(oldVNode, newVNode, container) {
+		if (oldVNode === newVNode) return;
+		if (!isSameVNode(oldVNode, newVNode)) {
+			const parent = hostParentNode(oldVNode.dom) || container;
+			const nextSibling = hostNextSibling(oldVNode.dom);
+			unmount(oldVNode, parent);
+			mount(newVNode, parent, nextSibling);
+			return;
+		}
+		if (oldVNode._effect) {
+			newVNode.dom = oldVNode.dom;
+			newVNode._effect = oldVNode._effect;
+			newVNode._subTree = oldVNode._subTree;
+			newVNode._slots = oldVNode._slots;
+			const props = oldVNode._componentProps;
+			newVNode._componentProps = props;
+			if (props) {
+				const newProps$1 = newVNode.props || {};
+				untrack(() => {
+					for (const key in newProps$1) if (key !== "children" && key !== "key" && key !== "ref") {
+						if (props[key] !== newProps$1[key]) props[key] = newProps$1[key];
+					}
+					for (const key in props) if (!(key in newProps$1) && key !== "children" && key !== "key" && key !== "ref") delete props[key];
+				});
+			}
+			const slotsRef = oldVNode._slots;
+			const newChildren = newVNode.props?.children;
+			const newSlotsFromProps = newVNode.props?.slots;
+			if (slotsRef) {
+				if (newChildren !== void 0) slotsRef._children = newChildren;
+				if (newSlotsFromProps !== void 0) slotsRef._slotsFromProps = newSlotsFromProps;
+				if (!isPatching) {
+					isPatching = true;
+					try {
+						untrack(() => {
+							slotsRef._version.v++;
+						});
+					} finally {
+						isPatching = false;
+					}
+				}
+			}
+			return;
+		}
+		if (newVNode.type === Text) {
+			newVNode.dom = oldVNode.dom;
+			if (oldVNode.text !== newVNode.text) hostSetText(newVNode.dom, String(newVNode.text));
+			return;
+		}
+		if (newVNode.type === Fragment) {
+			patchChildren(oldVNode, newVNode, container);
+			return;
+		}
+		const element = newVNode.dom = oldVNode.dom;
+		const oldProps = oldVNode.props || {};
+		const newProps = newVNode.props || {};
+		for (const key in oldProps) if (!(key in newProps) && key !== "children" && key !== "key" && key !== "ref") hostPatchProp(element, key, oldProps[key], null);
+		for (const key in newProps) {
+			const oldValue = oldProps[key];
+			const newValue = newProps[key];
+			if (key !== "children" && key !== "key" && key !== "ref" && oldValue !== newValue) hostPatchProp(element, key, oldValue, newValue);
+		}
+		patchChildren(oldVNode, newVNode, element);
+	}
+	function patchChildren(oldVNode, newVNode, container) {
+		const oldChildren = oldVNode.children;
+		const newChildren = newVNode.children;
+		newChildren.forEach((c) => c.parent = newVNode);
+		reconcileChildrenArray(container, oldChildren, newChildren);
+	}
+	function reconcileChildrenArray(parent, oldChildren, newChildren) {
+		let oldStartIdx = 0;
+		let oldEndIdx = oldChildren.length - 1;
+		let oldStartVNode = oldChildren[0];
+		let oldEndVNode = oldChildren[oldEndIdx];
+		let newStartIdx = 0;
+		let newEndIdx = newChildren.length - 1;
+		let newStartVNode = newChildren[0];
+		let newEndVNode = newChildren[newEndIdx];
+		let oldKeyToIdx;
+		while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) if (oldStartVNode == null) oldStartVNode = oldChildren[++oldStartIdx];
+		else if (oldEndVNode == null) oldEndVNode = oldChildren[--oldEndIdx];
+		else if (isSameVNode(oldStartVNode, newStartVNode)) {
+			patch(oldStartVNode, newStartVNode, parent);
+			oldStartVNode = oldChildren[++oldStartIdx];
+			newStartVNode = newChildren[++newStartIdx];
+		} else if (isSameVNode(oldEndVNode, newEndVNode)) {
+			patch(oldEndVNode, newEndVNode, parent);
+			oldEndVNode = oldChildren[--oldEndIdx];
+			newEndVNode = newChildren[--newEndIdx];
+		} else if (isSameVNode(oldStartVNode, newEndVNode)) {
+			patch(oldStartVNode, newEndVNode, parent);
+			const nodeToMove = oldStartVNode.dom;
+			const anchor = hostNextSibling(oldEndVNode.dom);
+			if (nodeToMove) hostInsert(nodeToMove, parent, anchor);
+			oldStartVNode = oldChildren[++oldStartIdx];
+			newEndVNode = newChildren[--newEndIdx];
+		} else if (isSameVNode(oldEndVNode, newStartVNode)) {
+			patch(oldEndVNode, newStartVNode, parent);
+			const nodeToMove = oldEndVNode.dom;
+			const anchor = oldStartVNode.dom;
+			if (nodeToMove) hostInsert(nodeToMove, parent, anchor);
+			oldEndVNode = oldChildren[--oldEndIdx];
+			newStartVNode = newChildren[++newStartIdx];
+		} else {
+			if (!oldKeyToIdx) oldKeyToIdx = createKeyToKeyIndexMap(oldChildren, oldStartIdx, oldEndIdx);
+			const idxInOld = newStartVNode.key != null ? oldKeyToIdx.get(String(newStartVNode.key)) : findIndexInOld(oldChildren, newStartVNode, oldStartIdx, oldEndIdx);
+			if (idxInOld != null) {
+				const vnodeToMove = oldChildren[idxInOld];
+				patch(vnodeToMove, newStartVNode, parent);
+				oldChildren[idxInOld] = void 0;
+				if (vnodeToMove.dom && oldStartVNode.dom) hostInsert(vnodeToMove.dom, parent, oldStartVNode.dom);
+			} else mount(newStartVNode, parent, oldStartVNode.dom);
+			newStartVNode = newChildren[++newStartIdx];
+		}
+		if (oldStartIdx > oldEndIdx) {
+			if (newStartIdx <= newEndIdx) {
+				const anchor = newChildren[newEndIdx + 1] == null ? null : newChildren[newEndIdx + 1].dom;
+				for (let i = newStartIdx; i <= newEndIdx; i++) mount(newChildren[i], parent, anchor);
+			}
+		} else if (newStartIdx > newEndIdx) {
+			for (let i = oldStartIdx; i <= oldEndIdx; i++) if (oldChildren[i]) unmount(oldChildren[i], parent);
+		}
+	}
+	function isSameVNode(n1, n2) {
+		const k1 = n1.key == null ? null : n1.key;
+		const k2 = n2.key == null ? null : n2.key;
+		if (n1.type !== n2.type) return false;
+		if (k1 === k2) return true;
+		return String(k1) === String(k2);
+	}
+	function createKeyToKeyIndexMap(children, beginIdx, endIdx) {
+		const map = /* @__PURE__ */ new Map();
+		for (let i = beginIdx; i <= endIdx; i++) {
+			const key = children[i]?.key;
+			if (key != null) map.set(String(key), i);
+		}
+		return map;
+	}
+	function findIndexInOld(children, newChild, beginIdx, endIdx) {
+		for (let i = beginIdx; i <= endIdx; i++) if (children[i] && isSameVNode(children[i], newChild)) return i;
+		return null;
+	}
+	function mountComponent(vnode, container, before, setup) {
+		const anchor = hostCreateComment("");
+		vnode.dom = anchor;
+		anchor.__vnode = vnode;
+		hostInsert(anchor, container, before);
+		let exposed = null;
+		let exposeCalled = false;
+		const { children, slots: slotsFromProps, ...propsData } = vnode.props || {};
+		const reactiveProps = signal$1(propsData);
+		vnode._componentProps = reactiveProps;
+		const slots = createSlots(children, slotsFromProps);
+		vnode._slots = slots;
+		const mountHooks = [];
+		const cleanupHooks = [];
+		const parentInstance = getCurrentInstance();
+		const componentName = vnode.type.__name;
+		const ctx = {
+			el: container,
+			signal: signal$1,
+			props: reactiveProps,
+			slots,
+			emit: (event, ...args) => {
+				const handler = reactiveProps[`on${event[0].toUpperCase() + event.slice(1)}`];
+				if (handler && typeof handler === "function") handler(...args);
+			},
+			parent: parentInstance,
+			onMount: (fn) => {
+				mountHooks.push(fn);
+			},
+			onCleanup: (fn) => {
+				cleanupHooks.push(fn);
+			},
+			expose: (exposedValue) => {
+				exposed = exposedValue;
+				exposeCalled = true;
+			}
+		};
+		ctx.__name = componentName;
+		if (currentAppContext) ctx._appContext = currentAppContext;
+		const componentInstance = {
+			name: componentName,
+			ctx,
+			vnode
+		};
+		const prev = setCurrentInstance(ctx);
+		let renderFn;
+		try {
+			renderFn = setup(ctx);
+			notifyComponentCreated(currentAppContext, componentInstance);
+		} catch (err) {
+			if (!handleComponentError(currentAppContext, err, componentInstance, "setup")) throw err;
+		} finally {
+			setCurrentInstance(prev);
+		}
+		if (vnode.props.ref) {
+			const refValue = exposeCalled ? exposed : null;
+			if (typeof vnode.props.ref === "function") vnode.props.ref(refValue);
+			else if (vnode.props.ref && typeof vnode.props.ref === "object") vnode.props.ref.current = refValue;
+		}
+		if (renderFn) vnode._effect = effect(() => {
+			const prevInstance = setCurrentInstance(ctx);
+			try {
+				const subTreeResult = renderFn();
+				if (subTreeResult == null) return;
+				const subTree = normalizeSubTree(subTreeResult);
+				const prevSubTree = vnode._subTree;
+				if (prevSubTree) {
+					patch(prevSubTree, subTree, container);
+					notifyComponentUpdated(currentAppContext, componentInstance);
+				} else mount(subTree, container, anchor);
+				vnode._subTree = subTree;
+			} catch (err) {
+				if (!handleComponentError(currentAppContext, err, componentInstance, "render")) throw err;
+			} finally {
+				setCurrentInstance(prevInstance);
+			}
+		});
+		const mountCtx = { el: container };
+		mountHooks.forEach((hook) => hook(mountCtx));
+		notifyComponentMounted(currentAppContext, componentInstance);
+		vnode.cleanup = () => {
+			notifyComponentUnmounted(currentAppContext, componentInstance);
+			cleanupHooks.forEach((hook) => hook(mountCtx));
+		};
+	}
+	/**
+	* Create slots object from children and slots prop.
+	* Uses a version signal to trigger re-renders when children change.
+	* Supports named slots via:
+	* - `slots` prop object (e.g., slots={{ header: () => <div>...</div> }})
+	* - `slot` prop on children (e.g., <div slot="header">...</div>)
+	*/
+	function createSlots(children, slotsFromProps) {
+		const versionSignal = signal$1({ v: 0 });
+		function extractNamedSlotsFromChildren(c) {
+			const defaultChildren = [];
+			const namedSlots = {};
+			if (c == null) return {
+				defaultChildren,
+				namedSlots
+			};
+			const items = Array.isArray(c) ? c : [c];
+			for (const child of items) if (child && typeof child === "object" && child.props && child.props.slot) {
+				const slotName = child.props.slot;
+				if (!namedSlots[slotName]) namedSlots[slotName] = [];
+				namedSlots[slotName].push(child);
+			} else defaultChildren.push(child);
+			return {
+				defaultChildren,
+				namedSlots
+			};
+		}
+		const slotsObj = {
+			_children: children,
+			_slotsFromProps: slotsFromProps || {},
+			_version: versionSignal,
+			default: function() {
+				this._version.v;
+				const c = this._children;
+				const { defaultChildren } = extractNamedSlotsFromChildren(c);
+				return defaultChildren;
+			}
+		};
+		return new Proxy(slotsObj, { get(target, prop) {
+			if (prop in target) return target[prop];
+			if (typeof prop === "string") return function(scopedProps) {
+				target._version.v;
+				if (target._slotsFromProps && typeof target._slotsFromProps[prop] === "function") {
+					const result = target._slotsFromProps[prop](scopedProps);
+					if (result == null) return [];
+					return Array.isArray(result) ? result : [result];
+				}
+				const { namedSlots } = extractNamedSlotsFromChildren(target._children);
+				return namedSlots[prop] || [];
+			};
+		} });
+	}
+	/**
+	* Normalize render result to a VNode (wrapping arrays in Fragment)
+	*/
+	function normalizeSubTree(result) {
+		if (Array.isArray(result)) return {
+			type: Fragment,
+			props: {},
+			key: null,
+			children: result,
+			dom: null
+		};
+		if (typeof result === "string" || typeof result === "number") return {
+			type: Text,
+			props: {},
+			key: null,
+			children: [],
+			dom: null,
+			text: result
+		};
+		return result;
+	}
+	return {
+		render,
+		createApp: (rootComponent) => {
+			return { mount(selectorOrContainer) {
+				let container = null;
+				if (typeof selectorOrContainer === "string") {
+					if (options.querySelector) container = options.querySelector(selectorOrContainer);
+				} else container = selectorOrContainer;
+				if (!container) {
+					console.warn(`Container not found: ${selectorOrContainer}`);
+					return;
+				}
+				render(rootComponent, container);
+			} };
+		}
+	};
+}
+
+//#endregion
+export { AppContextKey, Fragment, InstanceLifetimes, SubscriptionHandler, Text, Utils, createPropsProxy, createRenderer, createTopic, defineApp, defineComponent, defineFactory, defineInjectable, defineProvide, defineStore, getComponentMeta, getComponentPlugins, getCurrentInstance, getDefaultMount, getPlatformSyncProcessor, guid, handleComponentError, inject, injectApp, jsx, jsxDEV, jsxs, notifyComponentCreated, notifyComponentMounted, notifyComponentUnmounted, notifyComponentUpdated, onCleanup, onMount, provide, registerComponentPlugin, setCurrentInstance, setDefaultMount, setPlatformSyncProcessor, signal, toSubscriber, valueOf };
+//# sourceMappingURL=index.js.map