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

package/dist/compiler.esm-bundler.js

@@ -1,5 +1,5 @@
 /**
-* compiler v0.1.0
+* compiler v0.1.1-beta.0
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
@@ -142,6 +142,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",
@@ -166,7 +167,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
@@ -361,8 +364,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) {
@@ -588,7 +593,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 [];
@@ -671,7 +676,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);
 	const statements = [
 		t.variableDeclaration("const", [t.variableDeclarator(t.identifier(node.ref.name), emitTemplateClone(node, context))]),
@@ -818,11 +823,11 @@ function emitNodeExpression(node, context) {
 	switch (node.kind) {
 		case "Text": return t.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 t.nullLiteral();
@@ -830,15 +835,15 @@ function emitNodeExpression(node, context) {
 }
 //#endregion
 //#region packages/core/compiler/src/codegen/dom/emitComponent.ts
-function emitComponent(node, context) {
-	const props = t.objectExpression(node.props.map((prop) => emitComponentProp(prop, context)));
+function emitComponent$1(node, context) {
+	const props = t.objectExpression(node.props.map((prop) => emitComponentProp$1(prop, context)));
 	return t.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 t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(emitChildrenProp(prop.value, context))]));
 	const value = parseExpressionIR(prop.value);
-	if (isStaticPropValue(value)) return t.objectProperty(key, value);
+	if (isStaticPropValue$1(value)) return t.objectProperty(key, value);
 	return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(value)]));
 }
 function emitChildrenProp(children, context) {
@@ -846,15 +851,15 @@ function emitChildrenProp(children, context) {
 	if (nodes.length === 1) return nodes[0];
 	return t.arrayExpression(nodes);
 }
-function isStaticPropValue(value) {
+function isStaticPropValue$1(value) {
 	return t.isStringLiteral(value) || t.isNumericLiteral(value) || t.isBooleanLiteral(value) || t.isNullLiteral(value);
 }
-function createObjectKey$1(key) {
+function createObjectKey$2(key) {
 	return t.isValidIdentifier(key) ? t.identifier(key) : t.stringLiteral(key);
 }
 //#endregion
 //#region packages/core/compiler/src/codegen/dom/emitBuiltin.ts
-function emitShow(node, context) {
+function emitShow$1(node, context) {
 	const props = [t.objectProperty(t.identifier("when"), parseExpressionIR(node.when)), t.objectProperty(t.identifier("children"), t.arrowFunctionExpression([], emitChildrenProp(node.children, context)))];
 	if (node.fallback) props.push(t.objectProperty(t.identifier("fallback"), Array.isArray(node.fallback) ? t.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : parseExpressionIR(node.fallback)));
 	return t.callExpression(context.importRuntime("createComponent"), [context.importRuntime("Show"), t.objectExpression(props)]);
@@ -870,7 +875,7 @@ function emitMountShow(node, context) {
 		node.fallback ? Array.isArray(node.fallback) ? t.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : t.arrowFunctionExpression([], parseExpressionIR(node.fallback)) : t.identifier("undefined")
 	]);
 }
-function emitFor(node, context) {
+function emitFor$1(node, context) {
 	const params = [t.identifier(node.item.name)];
 	if (node.index) params.push(t.identifier(node.index.name));
 	const props = [t.objectProperty(t.identifier("each"), parseExpressionIR(node.each)), t.objectProperty(t.identifier("children"), t.arrowFunctionExpression(params, emitChildrenProp(node.body, context)))];
@@ -901,7 +906,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(t.objectProperty(key, expression));
 		else props.push(t.objectProperty(key, t.arrowFunctionExpression([], expression)));
@@ -914,7 +919,7 @@ function isStaticValue(expr) {
 function isGetterExpression(expr) {
 	return t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr);
 }
-function createObjectKey(name) {
+function createObjectKey$1(name) {
 	return t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
 }
 function emitSlot(node, context) {
@@ -927,11 +932,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 t.arrowFunctionExpression([], parseExpressionIR(node.expr));
@@ -939,6 +944,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",
@@ -950,6 +992,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
@@ -986,6 +1031,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 t.stringLiteral(decodeCompilerEscapedText(node.value));
+			return t.callExpression(context.importRuntime("ssrStatic"), [t.stringLiteral(node.value)]);
+		case "DynamicText":
+			if (rawTextTag) return parseExpressionIR(node.expr);
+			return t.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 = [t.arrowFunctionExpression([], parseExpressionIR(node.when)), t.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(t.arrowFunctionExpression([], fallback));
+	}
+	return t.callExpression(context.importRuntime("ssrShow"), args);
+}
+function emitFor(node, context, rawTextTag) {
+	const params = [t.identifier(node.item.name)];
+	if (node.index) params.push(t.identifier(node.index.name));
+	return t.callExpression(context.importRuntime("ssrFor"), [t.arrowFunctionExpression([], parseExpressionIR(node.each)), t.arrowFunctionExpression(params, emitChildrenValue(node.body, context, rawTextTag))]);
+}
+function emitComponent(node, context) {
+	return t.callExpression(context.importRuntime("ssrComponent"), [parseExpressionIR(node.callee), t.objectExpression(node.props.map((prop) => emitComponentProp(prop, context)))]);
+}
+function emitComponentProp(prop, context) {
+	const key = createObjectKey(prop.name);
+	if (Array.isArray(prop.value)) return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(emitChildrenValue(prop.value, context))]));
+	const value = parseExpressionIR(prop.value);
+	if (isStaticPropValue(value)) return t.objectProperty(key, value);
+	return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(value)]));
+}
+function emitElement(node, context) {
+	const rawTextTag = getSSRRawTextTag(node.tagName);
+	const args = [t.stringLiteral(node.tagName), t.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(t.identifier("undefined"));
+		args.push(t.booleanLiteral(true));
+	}
+	return t.callExpression(context.importRuntime("ssrElement"), args);
+}
+function emitAttributeBinding(attr, context) {
+	const name = normalizeAttributeName(attr.name);
+	return t.callExpression(context.importRuntime("ssrAttr"), [t.stringLiteral(name), emitBindingValue(attr.expr)]);
+}
+function emitPropertyBinding(attr, context) {
+	return t.callExpression(context.importRuntime("ssrProp"), [t.stringLiteral(attr.name), emitBindingValue(attr.expr)]);
+}
+function emitBindingValue(expression) {
+	const value = parseExpressionIR(expression);
+	if (t.isArrowFunctionExpression(value) || t.isFunctionExpression(value)) return t.callExpression(value, []);
+	return value;
+}
+function emitStaticAttribute(attr, context) {
+	return t.callExpression(context.importRuntime("ssrAttr"), [t.stringLiteral(normalizeAttributeName(attr.name)), attr.value === true ? t.booleanLiteral(true) : t.stringLiteral(attr.value)]);
+}
+function emitChildren(children, context, rawTextTag) {
+	return t.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 t.isStringLiteral(value) || t.isNumericLiteral(value) || t.isBooleanLiteral(value) || t.isNullLiteral(value);
+}
+function createObjectKey(name) {
+	return t.isValidIdentifier(name) ? t.identifier(name) : t.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;
@@ -1058,12 +1266,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) {
@@ -1330,7 +1541,8 @@ function lowerComponent(path, context) {
 	return componentIR({
 		ref: ref(context.uid("cmp$").name),
 		callee: tag,
-		props
+		props,
+		span: sourceSpanFromBabelNode(path.node)
 	});
 }
 function convertComponentIdentifier(node) {
@@ -1361,6 +1573,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("-")
@@ -1742,13 +1955,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));
 }