@zeus-js/compiler 0.1.0 → 0.1.1-beta.0

package/dist/compiler.global.js

@@ -1,5 +1,5 @@
 /**
-* compiler v0.1.0
+* compiler v0.1.1-beta.0
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
@@ -5743,6 +5743,7 @@ var ZeusCompiler = (function(exports) {
 	}
 	//#endregion
 	//#region packages/core/compiler/src/config/index.ts
+	const DEFAULT_SSR_RENDERER_MODULE = "@zeus-js/runtime-ssr";
 	const DEFAULT_OPTIONS = {
 		moduleName: DEFAULT_RENDERER_MODULE,
 		generate: "dom",
@@ -5767,7 +5768,9 @@ var ZeusCompiler = (function(exports) {
 	* @returns The resolved compiler options.
 	*/
 	function resolveConfig(options) {
-		return extend(DEFAULT_OPTIONS, options);
+		const config = extend({}, DEFAULT_OPTIONS, options);
+		if (config.generate === "ssr" && (options === null || options === void 0 ? void 0 : options.moduleName) === void 0) config.moduleName = DEFAULT_SSR_RENDERER_MODULE;
+		return config;
 	}
 	//#endregion
 	//#region packages/core/compiler/src/context/CompilerContext.ts
@@ -5962,8 +5965,10 @@ var ZeusCompiler = (function(exports) {
 	}
 	function exitProgram(config, path, state) {
 		if (state.get("skip")) return;
-		appendTemplates(path);
-		appendEvents(path);
+		if (config.generate === "dom") {
+			appendTemplates(path);
+			if (config.delegateEvents) appendEvents(path);
+		}
 		appendImportMethods(path);
 	}
 	function createProgramVisitor(config) {
@@ -18324,19 +18329,18 @@ var ZeusCompiler = (function(exports) {
 	}
 	function elementIR(input) {
 		var _input$attrs, _input$children;
-		return {
+		return _objectSpread2(_objectSpread2({
 			id: id(),
 			kind: "Element",
 			ref: input.ref,
 			tagName: input.tagName,
 			attrs: (_input$attrs = input.attrs) !== null && _input$attrs !== void 0 ? _input$attrs : [],
-			children: (_input$children = input.children) !== null && _input$children !== void 0 ? _input$children : [],
-			flags: _objectSpread2({
-				isSVG: false,
-				isVoid: false,
-				isCustomElement: input.tagName.includes("-")
-			}, input.flags)
-		};
+			children: (_input$children = input.children) !== null && _input$children !== void 0 ? _input$children : []
+		}, input.span === void 0 ? {} : { span: input.span }), {}, { flags: _objectSpread2({
+			isSVG: false,
+			isVoid: false,
+			isCustomElement: input.tagName.includes("-")
+		}, input.flags) });
 	}
 	function textIR(value) {
 		return {
@@ -18401,13 +18405,13 @@ var ZeusCompiler = (function(exports) {
 		};
 	}
 	function componentIR(input) {
-		return {
+		return _objectSpread2({
 			id: id(),
 			kind: "Component",
 			ref: input.ref,
 			callee: input.callee,
 			props: input.props
-		};
+		}, input.span === void 0 ? {} : { span: input.span });
 	}
 	function showIR(input) {
 		return {
@@ -18636,7 +18640,7 @@ var ZeusCompiler = (function(exports) {
 		];
 	}
 	function emitComponentInsert(node, context) {
-		return emitMarkerInsert(node, context, emitComponent(node, context));
+		return emitMarkerInsert(node, context, emitComponent$1(node, context));
 	}
 	function emitMarkerInsert(node, context, value) {
 		if (!node.domPath || node.domPath.kind !== "Marker") return [];
@@ -18717,7 +18721,7 @@ var ZeusCompiler = (function(exports) {
 	}
 	//#endregion
 	//#region packages/core/compiler/src/codegen/dom/emitElement.ts
-	function emitElement(node, context) {
+	function emitElement$1(node, context) {
 		if (!hasRuntimeWork(node)) return emitTemplateClone(node, context);
 		return callExpression(arrowFunctionExpression([], blockStatement([
 			variableDeclaration("const", [variableDeclarator(identifier(node.ref.name), emitTemplateClone(node, context))]),
@@ -18863,11 +18867,11 @@ var ZeusCompiler = (function(exports) {
 		switch (node.kind) {
 			case "Text": return stringLiteral(node.value);
 			case "DynamicText": return parseExpressionIR(node.expr);
-			case "Element": return emitElement(node, context);
-			case "Component": return emitComponent(node, context);
+			case "Element": return emitElement$1(node, context);
+			case "Component": return emitComponent$1(node, context);
 			case "Fragment": return emitFragment(node, context);
-			case "Show": return emitShow(node, context);
-			case "For": return emitFor(node, context);
+			case "Show": return emitShow$1(node, context);
+			case "For": return emitFor$1(node, context);
 			case "Host": return emitHost(node, context);
 			case "Slot": return emitSlot(node, context);
 			default: return nullLiteral();
@@ -18875,15 +18879,15 @@ var ZeusCompiler = (function(exports) {
 	}
 	//#endregion
 	//#region packages/core/compiler/src/codegen/dom/emitComponent.ts
-	function emitComponent(node, context) {
-		const props = objectExpression(node.props.map((prop) => emitComponentProp(prop, context)));
+	function emitComponent$1(node, context) {
+		const props = objectExpression(node.props.map((prop) => emitComponentProp$1(prop, context)));
 		return callExpression(context.importRuntime("createComponent"), [parseExpressionIR(node.callee), props]);
 	}
-	function emitComponentProp(prop, context) {
-		const key = createObjectKey$1(prop.name);
+	function emitComponentProp$1(prop, context) {
+		const key = createObjectKey$2(prop.name);
 		if (Array.isArray(prop.value)) return objectMethod("get", key, [], blockStatement([returnStatement(emitChildrenProp(prop.value, context))]));
 		const value = parseExpressionIR(prop.value);
-		if (isStaticPropValue(value)) return objectProperty(key, value);
+		if (isStaticPropValue$1(value)) return objectProperty(key, value);
 		return objectMethod("get", key, [], blockStatement([returnStatement(value)]));
 	}
 	function emitChildrenProp(children, context) {
@@ -18891,15 +18895,15 @@ var ZeusCompiler = (function(exports) {
 		if (nodes.length === 1) return nodes[0];
 		return arrayExpression(nodes);
 	}
-	function isStaticPropValue(value) {
+	function isStaticPropValue$1(value) {
 		return isStringLiteral(value) || isNumericLiteral(value) || isBooleanLiteral(value) || isNullLiteral(value);
 	}
-	function createObjectKey$1(key) {
+	function createObjectKey$2(key) {
 		return isValidIdentifier(key) ? identifier(key) : stringLiteral(key);
 	}
 	//#endregion
 	//#region packages/core/compiler/src/codegen/dom/emitBuiltin.ts
-	function emitShow(node, context) {
+	function emitShow$1(node, context) {
 		const props = [objectProperty(identifier("when"), parseExpressionIR(node.when)), objectProperty(identifier("children"), arrowFunctionExpression([], emitChildrenProp(node.children, context)))];
 		if (node.fallback) props.push(objectProperty(identifier("fallback"), Array.isArray(node.fallback) ? arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : parseExpressionIR(node.fallback)));
 		return callExpression(context.importRuntime("createComponent"), [context.importRuntime("Show"), objectExpression(props)]);
@@ -18915,7 +18919,7 @@ var ZeusCompiler = (function(exports) {
 			node.fallback ? Array.isArray(node.fallback) ? arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : arrowFunctionExpression([], parseExpressionIR(node.fallback)) : identifier("undefined")
 		]);
 	}
-	function emitFor(node, context) {
+	function emitFor$1(node, context) {
 		const params = [identifier(node.item.name)];
 		if (node.index) params.push(identifier(node.index.name));
 		const props = [objectProperty(identifier("each"), parseExpressionIR(node.each)), objectProperty(identifier("children"), arrowFunctionExpression(params, emitChildrenProp(node.body, context)))];
@@ -18945,7 +18949,7 @@ var ZeusCompiler = (function(exports) {
 	function buildHostProps(node, context) {
 		const props = [];
 		for (const attr of node.attrs) {
-			const key = createObjectKey(attr.name);
+			const key = createObjectKey$1(attr.name);
 			const expression = parseExpressionIR(attr.expr);
 			if (isStaticValue(expression) || isGetterExpression(expression)) props.push(objectProperty(key, expression));
 			else props.push(objectProperty(key, arrowFunctionExpression([], expression)));
@@ -18958,7 +18962,7 @@ var ZeusCompiler = (function(exports) {
 	function isGetterExpression(expr) {
 		return isArrowFunctionExpression(expr) || isFunctionExpression(expr);
 	}
-	function createObjectKey(name) {
+	function createObjectKey$1(name) {
 		return isValidIdentifier(name) ? identifier(name) : stringLiteral(name);
 	}
 	function emitSlot(node, context) {
@@ -18971,11 +18975,11 @@ var ZeusCompiler = (function(exports) {
 	//#region packages/core/compiler/src/codegen/dom/index.ts
 	function emitDOM(node, context) {
 		switch (node.kind) {
-			case "Element": return emitElement(node, context);
+			case "Element": return emitElement$1(node, context);
 			case "Fragment": return emitFragment(node, context);
-			case "Component": return emitComponent(node, context);
-			case "Show": return emitShow(node, context);
-			case "For": return emitFor(node, context);
+			case "Component": return emitComponent$1(node, context);
+			case "Show": return emitShow$1(node, context);
+			case "For": return emitFor$1(node, context);
 			case "Host": return emitHost(node, context);
 			case "Slot": return emitSlot(node, context);
 			case "DynamicText": return arrowFunctionExpression([], parseExpressionIR(node.expr));
@@ -18983,6 +18987,43 @@ var ZeusCompiler = (function(exports) {
 		}
 	}
 	//#endregion
+	//#region packages/core/compiler/src/codegen/ssr/rawText.ts
+	function getSSRRawTextTag(tagName) {
+		const normalized = tagName.toLowerCase();
+		return normalized === "script" || normalized === "style" ? normalized : void 0;
+	}
+	//#endregion
+	//#region packages/core/compiler/src/codegen/ssr/property.ts
+	const BOOLEAN_PROPERTY_ELEMENTS = {
+		checked: /* @__PURE__ */ new Set(["input"]),
+		disabled: /* @__PURE__ */ new Set([
+			"button",
+			"fieldset",
+			"input",
+			"optgroup",
+			"option",
+			"select",
+			"textarea"
+		]),
+		multiple: /* @__PURE__ */ new Set(["input", "select"]),
+		readOnly: /* @__PURE__ */ new Set(["input", "textarea"]),
+		selected: /* @__PURE__ */ new Set(["option"])
+	};
+	const VALUE_PROPERTY_ELEMENTS = /* @__PURE__ */ new Set([
+		"button",
+		"input",
+		"option",
+		"textarea"
+	]);
+	function isSSRPropertySupported(tag, name) {
+		var _BOOLEAN_PROPERTY_ELE;
+		const normalizedTag = tag.toLowerCase();
+		if (name === "tabIndex") return true;
+		if (name === "htmlFor") return normalizedTag === "label";
+		if (name === "value") return VALUE_PROPERTY_ELEMENTS.has(normalizedTag);
+		return Boolean((_BOOLEAN_PROPERTY_ELE = BOOLEAN_PROPERTY_ELEMENTS[name]) === null || _BOOLEAN_PROPERTY_ELE === void 0 ? void 0 : _BOOLEAN_PROPERTY_ELE.has(normalizedTag));
+	}
+	//#endregion
 	//#region packages/core/compiler/src/diagnostics/codes.ts
 	const CompilerErrorCode = {
 		UNSUPPORTED_SPREAD_ATTRIBUTE: "ZEUS_UNSUPPORTED_SPREAD_ATTRIBUTE",
@@ -18994,6 +19035,9 @@ var ZeusCompiler = (function(exports) {
 		INVALID_TRANSFORM_RESULT: "ZEUS_INVALID_TRANSFORM_RESULT",
 		UNSUPPORTED_NODE: "ZEUS_UNSUPPORTED_NODE",
 		INVALID_BUILTIN_USAGE: "ZEUS_INVALID_BUILTIN_USAGE",
+		UNSUPPORTED_SSR_BUILTIN: "ZEUS_UNSUPPORTED_SSR_BUILTIN",
+		UNSUPPORTED_SSR_PROPERTY: "ZEUS_UNSUPPORTED_SSR_PROPERTY",
+		UNSUPPORTED_SSR_RAW_TEXT_CHILD: "ZEUS_UNSUPPORTED_SSR_RAW_TEXT_CHILD",
 		INVALID_REF_USAGE: "ZEUS_INVALID_REF_USAGE"
 	};
 	//#endregion
@@ -19030,6 +19074,169 @@ var ZeusCompiler = (function(exports) {
 		}
 	};
 	//#endregion
+	//#region packages/core/compiler/src/codegen/ssr/validate.ts
+	function assertSSRSupported(node, filename, rawTextTag) {
+		if (rawTextTag && (node.kind === "Element" || node.kind === "Component")) throwUnsupportedSSRRawTextChild(node, rawTextTag, filename);
+		switch (node.kind) {
+			case "Host":
+			case "Slot": throwUnsupportedSSRBuiltin(node, filename);
+			case "Element":
+				for (const attribute of node.attrs) if (attribute.kind === "PropBinding" && !isSSRPropertySupported(node.tagName, attribute.name)) throwUnsupportedSSRProperty(node, attribute, filename);
+				const childRawTextTag = getSSRRawTextTag(node.tagName);
+				for (const child of node.children) assertSSRSupported(child, filename, childRawTextTag);
+				return;
+			case "Fragment":
+				for (const child of node.children) assertSSRSupported(child, filename, rawTextTag);
+				return;
+			case "Component":
+				for (const prop of node.props) {
+					if (!Array.isArray(prop.value)) continue;
+					for (const child of prop.value) assertSSRSupported(child, filename);
+				}
+				return;
+			case "Show":
+				for (const child of node.children) assertSSRSupported(child, filename, rawTextTag);
+				if (Array.isArray(node.fallback)) for (const child of node.fallback) assertSSRSupported(child, filename, rawTextTag);
+				return;
+			case "For":
+				for (const child of node.body) assertSSRSupported(child, filename, rawTextTag);
+				return;
+			case "Text":
+			case "DynamicText": return;
+		}
+	}
+	function throwUnsupportedSSRRawTextChild(node, tag, filename) {
+		throw new CompilerError({
+			code: CompilerErrorCode.UNSUPPORTED_SSR_RAW_TEXT_CHILD,
+			message: `${node.kind} children are not supported inside <${tag}> SSR raw text.`,
+			hint: "Use text expressions, Fragment, Show, or For directly inside the raw-text element.",
+			filename,
+			span: node.span
+		});
+	}
+	function throwUnsupportedSSRProperty(element, property, filename) {
+		var _ref, _property$span;
+		throw new CompilerError({
+			code: CompilerErrorCode.UNSUPPORTED_SSR_PROPERTY,
+			message: `Property "${property.name}" on <${element.tagName}> cannot be serialized by SSR codegen.`,
+			hint: "Use an equivalent HTML attribute binding or move this DOM-only property update to client code.",
+			filename,
+			span: (_ref = (_property$span = property.span) !== null && _property$span !== void 0 ? _property$span : property.expr.span) !== null && _ref !== void 0 ? _ref : element.span
+		});
+	}
+	function throwUnsupportedSSRBuiltin(node, filename) {
+		throw new CompilerError({
+			code: CompilerErrorCode.UNSUPPORTED_SSR_BUILTIN,
+			message: `<${node.kind}> is not supported by SSR codegen.`,
+			hint: "Render Web Components on the client; the SSR baseline supports DOM components only.",
+			filename,
+			span: node.span
+		});
+	}
+	//#endregion
+	//#region packages/core/compiler/src/codegen/ssr/index.ts
+	function emitSSR(node, context, rawTextTag) {
+		switch (node.kind) {
+			case "Element": return emitElement(node, context);
+			case "Fragment": return emitChildren(node.children, context, rawTextTag);
+			case "Text":
+				if (rawTextTag) return stringLiteral(decodeCompilerEscapedText(node.value));
+				return callExpression(context.importRuntime("ssrStatic"), [stringLiteral(node.value)]);
+			case "DynamicText":
+				if (rawTextTag) return parseExpressionIR(node.expr);
+				return callExpression(context.importRuntime("ssrText"), [parseExpressionIR(node.expr)]);
+			case "Component": return emitComponent(node, context);
+			case "Show": return emitShow(node, context, rawTextTag);
+			case "For": return emitFor(node, context, rawTextTag);
+			case "Host":
+			case "Slot": return throwUnsupportedSSRBuiltin(node);
+			default: return throwUnsupportedSSRNode(node);
+		}
+	}
+	function emitShow(node, context, rawTextTag) {
+		const args = [arrowFunctionExpression([], parseExpressionIR(node.when)), arrowFunctionExpression([], emitChildrenValue(node.children, context, rawTextTag))];
+		if (node.fallback) {
+			const fallback = Array.isArray(node.fallback) ? emitChildrenValue(node.fallback, context, rawTextTag) : parseExpressionIR(node.fallback);
+			args.push(arrowFunctionExpression([], fallback));
+		}
+		return callExpression(context.importRuntime("ssrShow"), args);
+	}
+	function emitFor(node, context, rawTextTag) {
+		const params = [identifier(node.item.name)];
+		if (node.index) params.push(identifier(node.index.name));
+		return callExpression(context.importRuntime("ssrFor"), [arrowFunctionExpression([], parseExpressionIR(node.each)), arrowFunctionExpression(params, emitChildrenValue(node.body, context, rawTextTag))]);
+	}
+	function emitComponent(node, context) {
+		return callExpression(context.importRuntime("ssrComponent"), [parseExpressionIR(node.callee), objectExpression(node.props.map((prop) => emitComponentProp(prop, context)))]);
+	}
+	function emitComponentProp(prop, context) {
+		const key = createObjectKey(prop.name);
+		if (Array.isArray(prop.value)) return objectMethod("get", key, [], blockStatement([returnStatement(emitChildrenValue(prop.value, context))]));
+		const value = parseExpressionIR(prop.value);
+		if (isStaticPropValue(value)) return objectProperty(key, value);
+		return objectMethod("get", key, [], blockStatement([returnStatement(value)]));
+	}
+	function emitElement(node, context) {
+		const rawTextTag = getSSRRawTextTag(node.tagName);
+		const args = [stringLiteral(node.tagName), arrayExpression(node.attrs.flatMap((attr) => {
+			switch (attr.kind) {
+				case "StaticAttribute":
+					if (isEventAttributeName$1(attr.name)) return [];
+					return [emitStaticAttribute(attr, context)];
+				case "AttrBinding": return [emitAttributeBinding(attr, context)];
+				case "PropBinding": return [emitPropertyBinding(attr, context)];
+				default: return [];
+			}
+		}))];
+		if (node.children.length > 0) args.push(emitChildren(node.children, context, rawTextTag));
+		if (node.flags.isVoid) {
+			if (node.children.length === 0) args.push(identifier("undefined"));
+			args.push(booleanLiteral(true));
+		}
+		return callExpression(context.importRuntime("ssrElement"), args);
+	}
+	function emitAttributeBinding(attr, context) {
+		const name = normalizeAttributeName(attr.name);
+		return callExpression(context.importRuntime("ssrAttr"), [stringLiteral(name), emitBindingValue(attr.expr)]);
+	}
+	function emitPropertyBinding(attr, context) {
+		return callExpression(context.importRuntime("ssrProp"), [stringLiteral(attr.name), emitBindingValue(attr.expr)]);
+	}
+	function emitBindingValue(expression) {
+		const value = parseExpressionIR(expression);
+		if (isArrowFunctionExpression(value) || isFunctionExpression(value)) return callExpression(value, []);
+		return value;
+	}
+	function emitStaticAttribute(attr, context) {
+		return callExpression(context.importRuntime("ssrAttr"), [stringLiteral(normalizeAttributeName(attr.name)), attr.value === true ? booleanLiteral(true) : stringLiteral(attr.value)]);
+	}
+	function emitChildren(children, context, rawTextTag) {
+		return arrayExpression(children.map((child) => emitSSR(child, context, rawTextTag)));
+	}
+	function emitChildrenValue(children, context, rawTextTag) {
+		if (children.length === 1) return emitSSR(children[0], context, rawTextTag);
+		return emitChildren(children, context, rawTextTag);
+	}
+	function decodeCompilerEscapedText(value) {
+		return value.replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+	}
+	function isStaticPropValue(value) {
+		return isStringLiteral(value) || isNumericLiteral(value) || isBooleanLiteral(value) || isNullLiteral(value);
+	}
+	function createObjectKey(name) {
+		return isValidIdentifier(name) ? identifier(name) : stringLiteral(name);
+	}
+	function normalizeAttributeName(name) {
+		return name === "className" ? "class" : name;
+	}
+	function isEventAttributeName$1(name) {
+		return name.length > 2 && name.slice(0, 2).toLowerCase() === "on";
+	}
+	function throwUnsupportedSSRNode(node) {
+		const kind = node.kind;
+		throw new Error(`Unsupported SSR IR node: ${kind}`);
+	}
+	//#endregion
 	//#region packages/core/compiler/src/adapters/babel/diagnostic.ts
 	function createBabelCompilerError(path, options) {
 		var _hub$file;
@@ -19102,12 +19309,15 @@ var ZeusCompiler = (function(exports) {
 			if (!expression.isExpression()) return null;
 			const expr = lowerExpressionIR(expression);
 			if (name === "ref") return refBindingIR(expr);
-			if (name.startsWith("on") && name.length > 2) return eventBindingIR(toEventName(name), expr);
+			if (isEventAttributeName(name)) return eventBindingIR(toEventName(name), expr);
 			if (name.startsWith("prop:")) return propBindingIR(name.slice(5), expr);
 			return attrBindingIR(name, expr);
 		}
 		return null;
 	}
+	function isEventAttributeName(name) {
+		return name.length > 2 && name.slice(0, 2).toLowerCase() === "on";
+	}
 	//#endregion
 	//#region packages/core/compiler/src/lower/lowerChildren.ts
 	function lowerChildren(children, context) {
@@ -19374,7 +19584,8 @@ var ZeusCompiler = (function(exports) {
 		return componentIR({
 			ref: ref(context.uid("cmp$").name),
 			callee: tag,
-			props
+			props,
+			span: sourceSpanFromBabelNode(path.node)
 		});
 	}
 	function convertComponentIdentifier(node) {
@@ -19405,6 +19616,7 @@ var ZeusCompiler = (function(exports) {
 			tagName,
 			attrs,
 			children: VoidElements.includes(tagName) ? [] : lowerChildren(path.get("children"), context),
+			span: sourceSpanFromBabelNode(path.node),
 			flags: {
 				isVoid: VoidElements.includes(tagName),
 				isCustomElement: tagName.includes("-")
@@ -19786,13 +19998,18 @@ var ZeusCompiler = (function(exports) {
 		const context = getCompilerContext(path, config);
 		const ir = lowerJSX(path, context);
 		normalizeChildren(ir);
+		if (config.generate === "ssr") assertSSRSupported(ir, state.filename);
 		validateBuiltins(ir, {
 			isDefineElementRenderRoot: isDefineElementRenderRoot(path),
 			filename: state.filename
 		});
+		analyzeBindings(ir);
+		if (config.generate === "ssr") {
+			path.replaceWith(emitSSR(ir, context));
+			return;
+		}
 		assignDomPaths(ir);
 		assignPhysicalDomPaths(ir);
-		analyzeBindings(ir);
 		collectTemplates(ir, context);
 		path.replaceWith(emitDOM(ir, context));
 	}