@sigx/server-renderer 0.1.6 → 0.1.7

package/dist/server-UBcHtkm-.js

@@ -0,0 +1,829 @@
+import { resolveBuiltInDirective, show } from "@sigx/runtime-dom";
+import { Fragment, Text, createPropsAccessor, getCurrentInstance, isComponent, isDirective, provideAppContext, setCurrentInstance, signal } from "sigx";
+var _initialized = false;
+function initShowForSSR() {
+	show.getSSRProps = ({ value }) => {
+		if (!value) return { style: { display: "none" } };
+	};
+}
+function initDirectivesForSSR() {
+	if (_initialized) return;
+	_initialized = true;
+	initShowForSSR();
+}
+function createSSRContext(options = {}) {
+	let componentId = 0;
+	const componentStack = [];
+	const head = [];
+	const pluginData = /* @__PURE__ */ new Map();
+	return {
+		_componentId: componentId,
+		_componentStack: componentStack,
+		_head: head,
+		_pluginData: pluginData,
+		_onComponentError: options.onComponentError,
+		_streaming: false,
+		_pendingAsync: [],
+		nextId() {
+			return ++componentId;
+		},
+		pushComponent(id) {
+			componentStack.push(id);
+		},
+		popComponent() {
+			return componentStack.pop();
+		},
+		addHead(html) {
+			head.push(html);
+		},
+		getHead() {
+			return head.join("\n");
+		},
+		getPluginData(pluginName) {
+			return pluginData.get(pluginName);
+		},
+		setPluginData(pluginName, data) {
+			pluginData.set(pluginName, data);
+		}
+	};
+}
+var ESCAPE = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function escapeHtml$1(s) {
+	return s.replace(/[&<>"']/g, (c) => ESCAPE[c]);
+}
+var kebabCache = {};
+var VOID_ELEMENTS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+function camelToKebab(str) {
+	if (str.startsWith("--")) return str;
+	return kebabCache[str] ||= str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+var listDelimiterRE = /;(?![^(]*\))/g;
+var propertyDelimiterRE = /:([^]+)/;
+var styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+	const ret = {};
+	cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+		if (item) {
+			const tmp = item.split(propertyDelimiterRE);
+			if (tmp.length > 1) ret[tmp[0].trim()] = tmp[1].trim();
+		}
+	});
+	return ret;
+}
+function stringifyStyle(style) {
+	let ret = "";
+	for (const key in style) {
+		const value = style[key];
+		if (value != null && value !== "") ret += `${camelToKebab(key)}:${value};`;
+	}
+	return ret;
+}
+function isTextContent(element) {
+	if (element == null || element === false || element === true) return false;
+	if (typeof element === "string" || typeof element === "number") return true;
+	return element.type === Text;
+}
+function mergeSSRStyles(elementStyle, directiveStyle) {
+	if (!elementStyle) return directiveStyle;
+	if (!directiveStyle) return elementStyle;
+	const a = typeof elementStyle === "string" ? parseStringStyle(elementStyle) : typeof elementStyle === "object" ? elementStyle : {};
+	const b = typeof directiveStyle === "string" ? parseStringStyle(directiveStyle) : typeof directiveStyle === "object" ? directiveStyle : {};
+	return {
+		...a,
+		...b
+	};
+}
+async function* renderToChunks(element, ctx, parentCtx = null, appContext = null) {
+	if (element == null || element === false || element === true) return;
+	if (typeof element === "string" || typeof element === "number") {
+		yield escapeHtml$1(String(element));
+		return;
+	}
+	const vnode = element;
+	if (vnode.type === Text) {
+		yield escapeHtml$1(String(vnode.text));
+		return;
+	}
+	if (vnode.type === Fragment) {
+		for (const child of vnode.children) yield* renderToChunks(child, ctx, parentCtx, appContext);
+		return;
+	}
+	if (isComponent(vnode.type)) {
+		const setup = vnode.type.__setup;
+		const componentName = vnode.type.__name || "Anonymous";
+		const { children, slots: slotsFromProps, $models: modelsData, ...propsData } = vnode.props || {};
+		const id = ctx.nextId();
+		ctx.pushComponent(id);
+		const slots = {
+			default: () => children ? Array.isArray(children) ? children : [children] : [],
+			...slotsFromProps
+		};
+		const ssrLoads = [];
+		let componentCtx = {
+			el: null,
+			signal,
+			props: createPropsAccessor(propsData),
+			slots,
+			emit: () => {},
+			parent: parentCtx,
+			onMounted: () => {},
+			onUnmounted: () => {},
+			onCreated: () => {},
+			onUpdated: () => {},
+			expose: () => {},
+			renderFn: null,
+			update: () => {},
+			ssr: {
+				load(fn) {
+					ssrLoads.push(fn());
+				},
+				isServer: true,
+				isHydrating: false
+			},
+			_ssrLoads: ssrLoads
+		};
+		if (ctx._plugins) for (const plugin of ctx._plugins) {
+			const transformed = plugin.server?.transformComponentContext?.(ctx, vnode, componentCtx);
+			if (transformed) componentCtx = transformed;
+		}
+		if (!parentCtx && appContext) provideAppContext(componentCtx, appContext);
+		const prev = setCurrentInstance(componentCtx);
+		try {
+			let renderFn = setup(componentCtx);
+			if (renderFn && typeof renderFn.then === "function") renderFn = await renderFn;
+			if (ssrLoads.length > 0) {
+				let asyncMode = ctx._streaming ? "stream" : "block";
+				let asyncPlaceholder;
+				let pluginHandled = false;
+				if (ctx._plugins) for (const plugin of ctx._plugins) {
+					const result = plugin.server?.handleAsyncSetup?.(id, ssrLoads, renderFn, ctx);
+					if (result) {
+						asyncMode = result.mode;
+						asyncPlaceholder = result.placeholder;
+						pluginHandled = true;
+						break;
+					}
+				}
+				if (asyncMode === "stream") {
+					yield asyncPlaceholder || `<div data-async-placeholder="${id}" style="display:contents;">`;
+					if (renderFn) {
+						const result = renderFn();
+						if (result) if (Array.isArray(result)) for (const item of result) yield* renderToChunks(item, ctx, componentCtx, appContext);
+						else yield* renderToChunks(result, ctx, componentCtx, appContext);
+					}
+					yield `</div>`;
+					if (!pluginHandled) {
+						const capturedRenderFn = renderFn;
+						const capturedCtx = ctx;
+						const capturedAppContext = appContext;
+						const deferredRender = (async () => {
+							await Promise.all(ssrLoads);
+							let html = "";
+							if (capturedRenderFn) {
+								const result = capturedRenderFn();
+								if (result) html = await renderVNodeToString(result, capturedCtx, capturedAppContext);
+							}
+							return html;
+						})();
+						ctx._pendingAsync.push({
+							id,
+							promise: deferredRender
+						});
+					}
+				} else if (asyncMode === "skip") {} else {
+					await Promise.all(ssrLoads);
+					if (renderFn) {
+						const result = renderFn();
+						if (result) if (Array.isArray(result)) for (const item of result) yield* renderToChunks(item, ctx, componentCtx, appContext);
+						else yield* renderToChunks(result, ctx, componentCtx, appContext);
+					}
+				}
+			} else if (renderFn) {
+				const result = renderFn();
+				if (result) if (Array.isArray(result)) for (const item of result) yield* renderToChunks(item, ctx, componentCtx, appContext);
+				else yield* renderToChunks(result, ctx, componentCtx, appContext);
+			}
+		} catch (e) {
+			const error = e instanceof Error ? e : new Error(String(e));
+			let fallbackHtml = null;
+			if (ctx._onComponentError) fallbackHtml = ctx._onComponentError(error, componentName, id);
+			if (fallbackHtml === null || fallbackHtml === void 0) fallbackHtml = `<!--ssr-error:${id}-->`;
+			if (fallbackHtml) yield fallbackHtml;
+			if (process.env.NODE_ENV !== "production") console.error(`Error rendering component ${componentName}:`, e);
+		} finally {
+			setCurrentInstance(prev || null);
+		}
+		if (ctx._plugins) for (const plugin of ctx._plugins) {
+			const transformed = plugin.server?.afterRenderComponent?.(id, vnode, "", ctx);
+			if (transformed) yield transformed;
+		}
+		yield `<!--$c:${id}-->`;
+		ctx.popComponent();
+		return;
+	}
+	if (typeof vnode.type === "string") {
+		const tagName = vnode.type;
+		let props = "";
+		let directiveSSRProps = null;
+		if (vnode.props) {
+			for (const key in vnode.props) if (key.startsWith("use:")) {
+				const propValue = vnode.props[key];
+				let def;
+				let value;
+				if (isDirective(propValue)) {
+					def = propValue;
+					value = void 0;
+				} else if (Array.isArray(propValue) && propValue.length >= 1 && isDirective(propValue[0])) {
+					def = propValue[0];
+					value = propValue[1];
+				} else {
+					const builtIn = resolveBuiltInDirective(key.slice(4));
+					if (builtIn) {
+						def = builtIn;
+						value = propValue;
+					} else {
+						const custom = appContext?.directives.get(key.slice(4));
+						if (custom) {
+							def = custom;
+							value = propValue;
+						}
+					}
+				}
+				if (def?.getSSRProps) {
+					const ssrProps = def.getSSRProps({ value });
+					if (ssrProps) {
+						if (!directiveSSRProps) directiveSSRProps = {};
+						for (const k in ssrProps) if (k === "style" && directiveSSRProps.style) directiveSSRProps.style = {
+							...directiveSSRProps.style,
+							...ssrProps.style
+						};
+						else if (k === "class" && directiveSSRProps.class) directiveSSRProps.class = directiveSSRProps.class + " " + ssrProps.class;
+						else directiveSSRProps[k] = ssrProps[k];
+					}
+				}
+			}
+		}
+		const allProps = directiveSSRProps ? {
+			...vnode.props,
+			...directiveSSRProps,
+			style: mergeSSRStyles(vnode.props?.style, directiveSSRProps?.style)
+		} : vnode.props;
+		for (const key in allProps) {
+			const value = allProps[key];
+			if (key === "children" || key === "key" || key === "ref") continue;
+			if (key.startsWith("client:")) continue;
+			if (key.startsWith("use:")) continue;
+			if (key === "style") {
+				const styleString = typeof value === "object" ? stringifyStyle(value) : String(value);
+				props += ` style="${escapeHtml$1(styleString)}"`;
+			} else if (key === "className") props += ` class="${escapeHtml$1(String(value))}"`;
+			else if (key.startsWith("on")) {} else if (value === true) props += ` ${key}`;
+			else if (value !== false && value != null) props += ` ${key}="${escapeHtml$1(String(value))}"`;
+		}
+		if (VOID_ELEMENTS.has(tagName)) {
+			yield `<${tagName}${props}>`;
+			return;
+		}
+		yield `<${tagName}${props}>`;
+		let prevWasText = false;
+		for (const child of vnode.children) {
+			const isText = isTextContent(child);
+			if (isText && prevWasText) yield "<!--t-->";
+			yield* renderToChunks(child, ctx, parentCtx, appContext);
+			prevWasText = isText;
+		}
+		yield `</${tagName}>`;
+	}
+}
+async function renderVNodeToString(element, ctx, appContext = null) {
+	let result = "";
+	for await (const chunk of renderToChunks(element, ctx, null, appContext)) result += chunk;
+	return result;
+}
+function renderToStringSync(element, ctx, parentCtx, appContext, buf) {
+	if (element == null || element === false || element === true) return true;
+	if (typeof element === "string" || typeof element === "number") {
+		buf.push(escapeHtml$1(String(element)));
+		return true;
+	}
+	const vnode = element;
+	if (vnode.type === Text) {
+		buf.push(escapeHtml$1(String(vnode.text)));
+		return true;
+	}
+	if (vnode.type === Fragment) {
+		for (const child of vnode.children) if (!renderToStringSync(child, ctx, parentCtx, appContext, buf)) return false;
+		return true;
+	}
+	if (isComponent(vnode.type)) {
+		const setup = vnode.type.__setup;
+		const componentName = vnode.type.__name || "Anonymous";
+		const { children, slots: slotsFromProps, $models: modelsData, ...propsData } = vnode.props || {};
+		const id = ctx.nextId();
+		ctx.pushComponent(id);
+		const slots = {
+			default: () => children ? Array.isArray(children) ? children : [children] : [],
+			...slotsFromProps
+		};
+		const ssrLoads = [];
+		let componentCtx = {
+			el: null,
+			signal,
+			props: createPropsAccessor(propsData),
+			slots,
+			emit: () => {},
+			parent: parentCtx,
+			onMounted: () => {},
+			onUnmounted: () => {},
+			onCreated: () => {},
+			onUpdated: () => {},
+			expose: () => {},
+			renderFn: null,
+			update: () => {},
+			ssr: {
+				load(fn) {
+					ssrLoads.push(fn());
+				},
+				isServer: true,
+				isHydrating: false
+			},
+			_ssrLoads: ssrLoads
+		};
+		if (ctx._plugins) for (const plugin of ctx._plugins) {
+			const transformed = plugin.server?.transformComponentContext?.(ctx, vnode, componentCtx);
+			if (transformed) componentCtx = transformed;
+		}
+		if (!parentCtx && appContext) provideAppContext(componentCtx, appContext);
+		const prev = setCurrentInstance(componentCtx);
+		try {
+			let renderFn = setup(componentCtx);
+			if (renderFn && typeof renderFn.then === "function") {
+				for (const p of ssrLoads) p.catch(() => {});
+				setCurrentInstance(prev || null);
+				ctx.popComponent();
+				return false;
+			}
+			if (ssrLoads.length > 0) {
+				for (const p of ssrLoads) p.catch(() => {});
+				setCurrentInstance(prev || null);
+				ctx.popComponent();
+				return false;
+			}
+			if (renderFn) {
+				const result = renderFn();
+				if (result) {
+					if (Array.isArray(result)) {
+						for (const item of result) if (!renderToStringSync(item, ctx, componentCtx, appContext, buf)) {
+							setCurrentInstance(prev || null);
+							ctx.popComponent();
+							return false;
+						}
+					} else if (!renderToStringSync(result, ctx, componentCtx, appContext, buf)) {
+						setCurrentInstance(prev || null);
+						ctx.popComponent();
+						return false;
+					}
+				}
+			}
+		} catch (e) {
+			const error = e instanceof Error ? e : new Error(String(e));
+			let fallbackHtml = null;
+			if (ctx._onComponentError) fallbackHtml = ctx._onComponentError(error, componentName, id);
+			if (fallbackHtml === null || fallbackHtml === void 0) fallbackHtml = `<!--ssr-error:${id}-->`;
+			if (fallbackHtml) buf.push(fallbackHtml);
+		} finally {
+			setCurrentInstance(prev || null);
+		}
+		if (ctx._plugins) for (const plugin of ctx._plugins) {
+			const transformed = plugin.server?.afterRenderComponent?.(id, vnode, "", ctx);
+			if (transformed) buf.push(transformed);
+		}
+		buf.push(`<!--$c:${id}-->`);
+		ctx.popComponent();
+		return true;
+	}
+	if (typeof vnode.type === "string") {
+		const tagName = vnode.type;
+		let props = "";
+		let directiveSSRProps = null;
+		if (vnode.props) {
+			for (const key in vnode.props) if (key.startsWith("use:")) {
+				const propValue = vnode.props[key];
+				let def;
+				let value;
+				if (isDirective(propValue)) {
+					def = propValue;
+					value = void 0;
+				} else if (Array.isArray(propValue) && propValue.length >= 1 && isDirective(propValue[0])) {
+					def = propValue[0];
+					value = propValue[1];
+				} else {
+					const builtIn = resolveBuiltInDirective(key.slice(4));
+					if (builtIn) {
+						def = builtIn;
+						value = propValue;
+					} else {
+						const custom = appContext?.directives.get(key.slice(4));
+						if (custom) {
+							def = custom;
+							value = propValue;
+						}
+					}
+				}
+				if (def?.getSSRProps) {
+					const ssrProps = def.getSSRProps({ value });
+					if (ssrProps) {
+						if (!directiveSSRProps) directiveSSRProps = {};
+						for (const k in ssrProps) if (k === "style" && directiveSSRProps.style) directiveSSRProps.style = {
+							...directiveSSRProps.style,
+							...ssrProps.style
+						};
+						else if (k === "class" && directiveSSRProps.class) directiveSSRProps.class = directiveSSRProps.class + " " + ssrProps.class;
+						else directiveSSRProps[k] = ssrProps[k];
+					}
+				}
+			}
+		}
+		const allProps = directiveSSRProps ? {
+			...vnode.props,
+			...directiveSSRProps,
+			style: mergeSSRStyles(vnode.props?.style, directiveSSRProps?.style)
+		} : vnode.props;
+		for (const key in allProps) {
+			const value = allProps[key];
+			if (key === "children" || key === "key" || key === "ref") continue;
+			if (key.startsWith("client:")) continue;
+			if (key.startsWith("use:")) continue;
+			if (key === "style") {
+				const styleString = typeof value === "object" ? stringifyStyle(value) : String(value);
+				props += ` style="${escapeHtml$1(styleString)}"`;
+			} else if (key === "className") props += ` class="${escapeHtml$1(String(value))}"`;
+			else if (key.startsWith("on")) {} else if (value === true) props += ` ${key}`;
+			else if (value !== false && value != null) props += ` ${key}="${escapeHtml$1(String(value))}"`;
+		}
+		if (VOID_ELEMENTS.has(tagName)) {
+			buf.push(`<${tagName}${props}>`);
+			return true;
+		}
+		buf.push(`<${tagName}${props}>`);
+		let prevWasText = false;
+		for (const child of vnode.children) {
+			const isText = isTextContent(child);
+			if (isText && prevWasText) buf.push("<!--t-->");
+			if (!renderToStringSync(child, ctx, parentCtx, appContext, buf)) return false;
+			prevWasText = isText;
+		}
+		buf.push(`</${tagName}>`);
+		return true;
+	}
+	return true;
+}
+function escapeJsonForScript(json) {
+	return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function generateStreamingScript() {
+	return `
+<script>
+window.$SIGX_REPLACE = function(id, html) {
+    var placeholder = document.querySelector('[data-async-placeholder="' + id + '"]');
+    if (placeholder) {
+        var template = document.createElement('template');
+        template.innerHTML = html;
+        placeholder.innerHTML = '';
+        while (template.content.firstChild) {
+            placeholder.appendChild(template.content.firstChild);
+        }
+        placeholder.dispatchEvent(new CustomEvent('sigx:async-ready', { bubbles: true, detail: { id: id } }));
+    }
+};
+<\/script>`;
+}
+function generateReplacementScript(id, html, extraScript) {
+	let script = `<script>$SIGX_REPLACE(${id}, ${escapeJsonForScript(JSON.stringify(html))});`;
+	if (extraScript) script += extraScript;
+	script += `<\/script>`;
+	return script;
+}
+var _ssrHeadConfigs = [];
+var _isSSR = false;
+function enableSSRHead() {
+	_isSSR = true;
+	_ssrHeadConfigs = [];
+}
+function collectSSRHead() {
+	_isSSR = false;
+	const configs = _ssrHeadConfigs;
+	_ssrHeadConfigs = [];
+	return configs;
+}
+function renderHeadToString(configs) {
+	const parts = [];
+	const seenMeta = /* @__PURE__ */ new Map();
+	let finalTitle;
+	let titleTemplate;
+	for (const config of configs) {
+		if (config.titleTemplate) titleTemplate = config.titleTemplate;
+		if (config.title) finalTitle = config.title;
+		if (config.meta) for (const meta of config.meta) {
+			const key = meta.name ? `name:${meta.name}` : meta.property ? `property:${meta.property}` : meta["http-equiv"] ? `http-equiv:${meta["http-equiv"]}` : meta.charset ? "charset" : null;
+			const tag = `<meta ${Object.entries(meta).filter(([, v]) => v !== void 0).map(([k, v]) => `${escapeAttr(k)}="${escapeAttr(String(v))}"`).join(" ")}>`;
+			if (key) seenMeta.set(key, tag);
+			else parts.push(tag);
+		}
+		if (config.link) for (const link of config.link) {
+			const attrs = Object.entries(link).filter(([, v]) => v !== void 0).map(([k, v]) => `${escapeAttr(k)}="${escapeAttr(String(v))}"`).join(" ");
+			parts.push(`<link ${attrs}>`);
+		}
+		if (config.script) for (const script of config.script) {
+			const { innerHTML, ...rest } = script;
+			const attrs = Object.entries(rest).filter(([, v]) => v !== void 0 && v !== false).map(([k, v]) => v === true ? escapeAttr(k) : `${escapeAttr(k)}="${escapeAttr(String(v))}"`).join(" ");
+			if (innerHTML) parts.push(`<script ${attrs}>${innerHTML}<\/script>`);
+			else parts.push(`<script ${attrs}><\/script>`);
+		}
+	}
+	const result = [];
+	if (finalTitle) {
+		const title = titleTemplate ? titleTemplate.replace("%s", finalTitle) : finalTitle;
+		result.push(`<title>${escapeHtml(title)}</title>`);
+	}
+	for (const tag of seenMeta.values()) result.push(tag);
+	result.push(...parts);
+	return result.join("\n");
+}
+var _headToken = 0;
+function applyHeadClient(config) {
+	const managed = [];
+	const token = ++_headToken;
+	if (config.title) {
+		const title = config.titleTemplate ? config.titleTemplate.replace("%s", config.title) : config.title;
+		document.title = title;
+	}
+	if (config.meta) for (const meta of config.meta) {
+		const selector = meta.name ? `meta[name="${meta.name}"]` : meta.property ? `meta[property="${meta.property}"]` : meta["http-equiv"] ? `meta[http-equiv="${meta["http-equiv"]}"]` : null;
+		if (selector) {
+			const existing = document.querySelector(selector);
+			if (existing) existing.remove();
+		}
+		const el = document.createElement("meta");
+		for (const [k, v] of Object.entries(meta)) if (v !== void 0) el.setAttribute(k, v);
+		el.setAttribute("data-sigx-head", String(token));
+		document.head.appendChild(el);
+		managed.push(el);
+	}
+	if (config.link) for (const link of config.link) {
+		const el = document.createElement("link");
+		for (const [k, v] of Object.entries(link)) if (v !== void 0) el.setAttribute(k, v);
+		el.setAttribute("data-sigx-head", String(token));
+		document.head.appendChild(el);
+		managed.push(el);
+	}
+	if (config.script) for (const script of config.script) {
+		const { innerHTML, ...rest } = script;
+		const el = document.createElement("script");
+		for (const [k, v] of Object.entries(rest)) if (v === true) el.setAttribute(k, "");
+		else if (v !== void 0 && v !== false) el.setAttribute(k, String(v));
+		if (innerHTML) el.textContent = innerHTML;
+		el.setAttribute("data-sigx-head", String(token));
+		document.head.appendChild(el);
+		managed.push(el);
+	}
+	if (config.htmlAttrs) {
+		for (const [k, v] of Object.entries(config.htmlAttrs)) if (v !== void 0) document.documentElement.setAttribute(k, v);
+	}
+	if (config.bodyAttrs) {
+		for (const [k, v] of Object.entries(config.bodyAttrs)) if (v !== void 0) document.body.setAttribute(k, v);
+	}
+	return () => {
+		for (const el of managed) el.remove();
+	};
+}
+function useHead(config) {
+	if (_isSSR) {
+		_ssrHeadConfigs.push(config);
+		return;
+	}
+	const cleanup = applyHeadClient(config);
+	const instance = getCurrentInstance();
+	if (instance) instance.onUnmounted(() => cleanup());
+}
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+	return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function isApp(input) {
+	return input && typeof input === "object" && "_rootComponent" in input && "_context" in input;
+}
+function extractInput(input) {
+	if (isApp(input)) return {
+		element: input._rootComponent,
+		appContext: input._context
+	};
+	return {
+		element: input,
+		appContext: null
+	};
+}
+async function* streamAllAsyncChunks(ctx, plugins) {
+	const hasCoreAsync = ctx._pendingAsync.length > 0;
+	const pluginGenerators = [];
+	for (const plugin of plugins) {
+		const chunks = plugin.server?.getStreamingChunks?.(ctx);
+		if (chunks) pluginGenerators.push(chunks);
+	}
+	const hasPluginStreaming = pluginGenerators.length > 0;
+	if (!hasCoreAsync && !hasPluginStreaming) return;
+	if (hasCoreAsync) yield generateStreamingScript();
+	const corePromises = ctx._pendingAsync.map((pending, index) => pending.promise.then((html) => {
+		let finalHtml = html;
+		let extraScript = "";
+		for (const plugin of plugins) {
+			const result = plugin.server?.onAsyncComponentResolved?.(pending.id, finalHtml, ctx);
+			if (result) {
+				if (result.html !== void 0) finalHtml = result.html;
+				if (result.script) extraScript += result.script;
+			}
+		}
+		return {
+			index,
+			script: generateReplacementScript(pending.id, finalHtml, extraScript || void 0)
+		};
+	}).catch((error) => {
+		if (process.env.NODE_ENV !== "production") console.error(`Error streaming async component ${pending.id}:`, error);
+		return {
+			index,
+			script: generateReplacementScript(pending.id, `<div style="color:red;">Error loading component</div>`)
+		};
+	}));
+	const totalCore = corePromises.length;
+	const pumps = pluginGenerators.map((g) => ({
+		generator: g,
+		done: false
+	}));
+	const activePumps = /* @__PURE__ */ new Map();
+	function pumpNext(pumpIdx) {
+		const slotIndex = totalCore + pumpIdx;
+		return pumps[pumpIdx].generator.next().then(({ value, done }) => {
+			if (done) {
+				pumps[pumpIdx].done = true;
+				activePumps.delete(slotIndex);
+				return {
+					index: slotIndex,
+					script: ""
+				};
+			}
+			const nextP = pumpNext(pumpIdx);
+			activePumps.set(slotIndex, nextP);
+			return {
+				index: slotIndex,
+				script: value || ""
+			};
+		});
+	}
+	for (let i = 0; i < pumps.length; i++) {
+		const slotIndex = totalCore + i;
+		const p = pumpNext(i);
+		activePumps.set(slotIndex, p);
+	}
+	const resolvedCore = /* @__PURE__ */ new Set();
+	function getRaceablePromises() {
+		const promises = [];
+		for (let i = 0; i < totalCore; i++) if (!resolvedCore.has(i)) promises.push(corePromises[i]);
+		for (const [, p] of activePumps) promises.push(p);
+		return promises;
+	}
+	while (true) {
+		const raceable = getRaceablePromises();
+		if (raceable.length === 0) break;
+		const winner = await Promise.race(raceable);
+		if (winner.script) yield winner.script;
+		if (winner.index < totalCore) resolvedCore.add(winner.index);
+	}
+}
+function createSSR() {
+	const plugins = [];
+	function makeContext(options) {
+		const ctx = options && "_componentId" in options ? options : createSSRContext(options);
+		ctx._plugins = plugins;
+		for (const plugin of plugins) plugin.server?.setup?.(ctx);
+		return ctx;
+	}
+	return {
+		use(plugin) {
+			plugins.push(plugin);
+			return this;
+		},
+		async render(input, options) {
+			const { element, appContext } = extractInput(input);
+			enableSSRHead();
+			let result = "";
+			let ctx;
+			const syncCtx = makeContext(options);
+			const buf = [];
+			if (renderToStringSync(element, syncCtx, null, appContext, buf)) {
+				result = buf.join("");
+				ctx = syncCtx;
+			} else {
+				ctx = makeContext(options);
+				for await (const chunk of renderToChunks(element, ctx, null, appContext)) result += chunk;
+			}
+			for (const plugin of plugins) {
+				const injected = plugin.server?.getInjectedHTML?.(ctx);
+				if (injected) result += typeof injected === "string" ? injected : await injected;
+			}
+			for (const plugin of plugins) {
+				const chunks = plugin.server?.getStreamingChunks?.(ctx);
+				if (chunks) for await (const chunk of chunks) result += chunk;
+			}
+			const headConfigs = collectSSRHead();
+			if (headConfigs.length > 0) ctx.addHead(renderHeadToString(headConfigs));
+			return result;
+		},
+		renderStream(input, options) {
+			const ctx = makeContext(options);
+			ctx._streaming = true;
+			const { element, appContext } = extractInput(input);
+			return new ReadableStream({ async start(controller) {
+				try {
+					enableSSRHead();
+					for await (const chunk of renderToChunks(element, ctx, null, appContext)) controller.enqueue(chunk);
+					const headConfigs = collectSSRHead();
+					if (headConfigs.length > 0) ctx.addHead(renderHeadToString(headConfigs));
+					for (const plugin of plugins) {
+						const injected = plugin.server?.getInjectedHTML?.(ctx);
+						if (injected) {
+							const html = typeof injected === "string" ? injected : await injected;
+							if (html) controller.enqueue(html);
+						}
+					}
+					for await (const chunk of streamAllAsyncChunks(ctx, plugins)) controller.enqueue(chunk);
+					controller.enqueue(`<script>window.__SIGX_STREAMING_COMPLETE__=true;window.dispatchEvent(new Event('sigx:ready'));<\/script>`);
+					controller.close();
+				} catch (error) {
+					controller.error(error);
+				}
+			} });
+		},
+		async renderStreamWithCallbacks(input, callbacks, options) {
+			const ctx = makeContext(options);
+			ctx._streaming = true;
+			const { element, appContext } = extractInput(input);
+			try {
+				enableSSRHead();
+				let shellHtml = "";
+				for await (const chunk of renderToChunks(element, ctx, null, appContext)) shellHtml += chunk;
+				const headConfigs = collectSSRHead();
+				if (headConfigs.length > 0) ctx.addHead(renderHeadToString(headConfigs));
+				for (const plugin of plugins) {
+					const injected = plugin.server?.getInjectedHTML?.(ctx);
+					if (injected) shellHtml += typeof injected === "string" ? injected : await injected;
+				}
+				shellHtml += `<script>window.__SIGX_STREAMING_COMPLETE__=true;window.dispatchEvent(new Event('sigx:ready'));<\/script>`;
+				callbacks.onShellReady(shellHtml);
+				for await (const chunk of streamAllAsyncChunks(ctx, plugins)) callbacks.onAsyncChunk(chunk);
+				callbacks.onComplete();
+			} catch (error) {
+				callbacks.onError(error);
+			}
+		},
+		createContext(options) {
+			return makeContext(options);
+		}
+	};
+}
+var _defaultSSR = createSSR();
+function renderToStream(input, context) {
+	return _defaultSSR.renderStream(input, context);
+}
+async function renderToStreamWithCallbacks(input, callbacks, context) {
+	return _defaultSSR.renderStreamWithCallbacks(input, callbacks, context);
+}
+async function renderToString(input, context) {
+	return _defaultSSR.render(input, context);
+}
+initDirectivesForSSR();
+export { collectSSRHead as a, useHead as c, generateStreamingScript as d, renderVNodeToString as f, createSSR as i, escapeJsonForScript as l, initDirectivesForSSR as m, renderToStreamWithCallbacks as n, enableSSRHead as o, createSSRContext as p, renderToString as r, renderHeadToString as s, renderToStream as t, generateReplacementScript as u };
+
+//# sourceMappingURL=server-UBcHtkm-.js.map