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

package/dist/compiler.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* compiler v0.1.0
+* compiler v0.1.1-beta.0
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
@@ -5738,6 +5738,7 @@ function appendEvents(path) {
 }
 //#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",
@@ -5762,7 +5763,9 @@ const DEFAULT_OPTIONS = {
 * @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
@@ -5957,8 +5960,10 @@ function enterProgram(config, path, state) {
 }
 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) {
@@ -18319,19 +18324,18 @@ function identifierIR(name, span) {
 }
 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 {
@@ -18396,13 +18400,13 @@ function refBindingIR(expr) {
 	};
 }
 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 {
@@ -18631,7 +18635,7 @@ function emitDynamicText(node, context) {
 	];
 }
 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 [];
@@ -18712,7 +18716,7 @@ function emitTemplateClone(node, context) {
 }
 //#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))]),
@@ -18858,11 +18862,11 @@ function emitNodeExpression(node, context) {
 	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();
@@ -18870,15 +18874,15 @@ function emitNodeExpression(node, context) {
 }
 //#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) {
@@ -18886,15 +18890,15 @@ function emitChildrenProp(children, context) {
 	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)]);
@@ -18910,7 +18914,7 @@ function emitMountShow(node, context) {
 		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)))];
@@ -18940,7 +18944,7 @@ function emitHost(node, context) {
 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)));
@@ -18953,7 +18957,7 @@ function isStaticValue(expr) {
 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) {
@@ -18966,11 +18970,11 @@ function emitMarkerIdentifier(node) {
 //#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));
@@ -18978,6 +18982,43 @@ function emitDOM(node, context) {
 	}
 }
 //#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",
@@ -18989,6 +19030,9 @@ const CompilerErrorCode = {
 	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
@@ -19025,6 +19069,169 @@ var CompilerError = class extends Error {
 	}
 };
 //#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;
@@ -19097,12 +19304,15 @@ function lowerAttribute(path, _context) {
 		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) {
@@ -19369,7 +19579,8 @@ function lowerComponent(path, context) {
 	return componentIR({
 		ref: ref(context.uid("cmp$").name),
 		callee: tag,
-		props
+		props,
+		span: sourceSpanFromBabelNode(path.node)
 	});
 }
 function convertComponentIdentifier(node) {
@@ -19400,6 +19611,7 @@ function lowerElement(path, context) {
 		tagName,
 		attrs,
 		children: VoidElements.includes(tagName) ? [] : lowerChildren(path.get("children"), context),
+		span: sourceSpanFromBabelNode(path.node),
 		flags: {
 			isVoid: VoidElements.includes(tagName),
 			isCustomElement: tagName.includes("-")
@@ -19781,13 +19993,18 @@ function transformJSX(path, state, config) {
 	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));
 }