@analogjs/vite-plugin-angular 3.0.0-alpha.36 → 3.0.0-alpha.38

package/src/lib/compiler/metadata.js

@@ -0,0 +1,633 @@
+import { SIGNAL_APIS } from "./constants.js";
+import { unwrapForwardRefOxc } from "./utils.js";
+import * as o from "@angular/compiler";
+//#region packages/vite-plugin-angular/src/lib/compiler/metadata.ts
+function getCallApi(call) {
+	const callee = call.callee;
+	if (!callee) return null;
+	if (callee.type === "Identifier") return {
+		api: callee.name,
+		required: false
+	};
+	if ((callee.type === "StaticMemberExpression" || callee.type === "MemberExpression") && callee.object?.type === "Identifier" && callee.property?.name === "required") return {
+		api: callee.object.name,
+		required: true
+	};
+	return null;
+}
+/**
+* Extract the string value from an OXC string literal or template literal node.
+*
+* If `consts` is provided, interpolated template literals (e.g.
+* `\`hello ${NAME}\``) are resolved when every `${...}` expression is a bare
+* `Identifier` whose name is present in the map. This lets metadata fields
+* such as `template:` reference module-level string constants via JS
+* template-literal interpolation:
+*
+*   const tw = `text-zinc-700 hover:text-zinc-900`;
+*   @Component({ template: `<a class="${tw}">x</a>` })
+*
+* Returns `null` if the node is not statically resolvable.
+*/
+function stringValue(node, consts) {
+	if (node?.type === "StringLiteral") return node.value;
+	if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node?.type === "TemplateLiteral") {
+		const quasis = node.quasis ?? [];
+		const expressions = node.expressions ?? [];
+		if (expressions.length === 0) return quasis[0]?.value?.cooked ?? null;
+		if (!consts) return null;
+		let result = "";
+		for (let i = 0; i < quasis.length; i++) {
+			const cooked = quasis[i]?.value?.cooked;
+			if (cooked == null) return null;
+			result += cooked;
+			if (i < expressions.length) {
+				const expr = expressions[i];
+				if (expr?.type !== "Identifier") return null;
+				const resolved = consts.get(expr.name);
+				if (resolved == null) return null;
+				result += resolved;
+			}
+		}
+		return result;
+	}
+	return null;
+}
+/**
+* Walk the top-level statements of an OXC program and collect a map of
+* statically-resolvable string-valued `const NAME = ...` declarations.
+*
+* Used so decorator metadata fields like `template:` can reference
+* module-level Tailwind class chains (or any other string constants) via
+* JS template-literal interpolation. Resolution is iterative: a const may
+* reference earlier-resolved consts via `${other}` interpolation.
+*
+* Only `const` declarations are considered. Non-string initializers,
+* function calls, member access, and any expression that cannot be reduced
+* to a string at parse time are ignored.
+*/
+function collectStringConstants(oxcProgram) {
+	const rawDecls = /* @__PURE__ */ new Map();
+	for (const stmt of oxcProgram?.body || []) {
+		const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+		if (!decl || decl.type !== "VariableDeclaration" || decl.kind !== "const") continue;
+		for (const d of decl.declarations || []) if (d.id?.type === "Identifier" && d.init) rawDecls.set(d.id.name, d.init);
+	}
+	const resolved = /* @__PURE__ */ new Map();
+	for (let pass = 0; pass < rawDecls.size + 1; pass++) {
+		let progress = false;
+		for (const [name, init] of rawDecls) {
+			if (resolved.has(name)) continue;
+			const value = stringValue(init, resolved);
+			if (value !== null) {
+				resolved.set(name, value);
+				progress = true;
+			}
+		}
+		if (!progress) break;
+	}
+	return resolved;
+}
+/** Get the property key name from an OXC object property. */
+function propKeyName(prop) {
+	if (!prop.key) return null;
+	return prop.key.name ?? prop.key.value ?? null;
+}
+/**
+* Extract decorator metadata from an OXC decorator AST node.
+* Parses @Component, @Directive, @Pipe, @Injectable, @NgModule arguments.
+*
+* `stringConsts`, when provided, lets string-typed metadata fields
+* (`template`, `selector`, `templateUrl`, `styles`, `styleUrl`, `styleUrls`,
+* `name`, `exportAs`, `providedIn`) resolve module-level string constants
+* referenced via template-literal interpolation, e.g.
+* `template: \`<div class="${tw}">x</div>\``.
+*/
+function extractMetadata(dec, sourceCode, stringConsts) {
+	if (!dec) return null;
+	const call = dec.expression;
+	if (!call || call.type !== "CallExpression") return null;
+	const arg = call.arguments?.[0];
+	const meta = {
+		hostRaw: {},
+		inputs: {},
+		outputs: {},
+		standalone: true,
+		imports: [],
+		providers: null,
+		viewProviders: null,
+		animations: null,
+		changeDetection: null,
+		encapsulation: null,
+		preserveWhitespaces: false,
+		exportAs: null,
+		selector: void 0,
+		styles: [],
+		templateUrl: null,
+		styleUrls: []
+	};
+	if (!arg || arg.type !== "ObjectExpression") return meta;
+	for (const p of arg.properties || []) {
+		if (p.type !== "ObjectProperty" && p.type !== "Property") continue;
+		const key = propKeyName(p);
+		if (!key) continue;
+		const valNode = p.value;
+		const valText = sourceCode.slice(valNode.start, valNode.end);
+		switch (key) {
+			case "host":
+				if (valNode.type === "ObjectExpression") for (const hp of valNode.properties || []) {
+					if (hp.type !== "ObjectProperty" && hp.type !== "Property") continue;
+					const hKey = propKeyName(hp);
+					if (!hKey) continue;
+					const sv = stringValue(hp.value, stringConsts);
+					const hVal = sv !== null ? sv : sourceCode.slice(hp.value.start, hp.value.end).replace(/^['"`]|['"`]$/g, "");
+					meta.hostRaw[hKey.replace(/^['"`]|['"`]$/g, "")] = hVal;
+				}
+				break;
+			case "changeDetection":
+				meta.changeDetection = valText.includes("OnPush") ? 0 : 1;
+				break;
+			case "encapsulation":
+				meta.encapsulation = valText.includes("None") ? 2 : valText.includes("ShadowDom") ? 3 : 0;
+				break;
+			case "preserveWhitespaces":
+				meta.preserveWhitespaces = valText === "true";
+				break;
+			case "pure":
+			case "standalone":
+				meta[key] = valText !== "false";
+				break;
+			case "template":
+			case "selector":
+			case "name":
+			case "exportAs":
+			case "templateUrl":
+			case "providedIn": {
+				const sv = stringValue(valNode, stringConsts);
+				if (sv !== null) meta[key] = sv;
+				else if (valNode.type === "TemplateLiteral") {
+					const quasis = valNode.quasis ?? [];
+					const expressions = valNode.expressions ?? [];
+					let result = "";
+					for (let i = 0; i < quasis.length; i++) {
+						result += quasis[i]?.value?.cooked ?? "";
+						if (i < expressions.length) {
+							const expr = expressions[i];
+							if (expr?.type === "Identifier") {
+								const resolved = stringConsts?.get(expr.name);
+								if (resolved != null) {
+									result += resolved;
+									continue;
+								}
+							}
+						}
+					}
+					meta[key] = result;
+				} else meta[key] = valText.replace(/^['"`]|['"`]$/g, "");
+				if (key === "exportAs") meta.exportAs = [meta.exportAs];
+				break;
+			}
+			case "styleUrl": {
+				const sv = stringValue(valNode, stringConsts);
+				meta.styleUrls = [sv !== null ? sv : valText.replace(/['"`]/g, "")];
+				break;
+			}
+			case "styleUrls":
+				if (valNode.type === "ArrayExpression") meta.styleUrls = (valNode.elements || []).map((e) => {
+					const sv = stringValue(e, stringConsts);
+					return sv !== null ? sv : sourceCode.slice(e.start, e.end).replace(/['"`]/g, "");
+				});
+				break;
+			case "styles":
+				if (valNode.type === "ArrayExpression") meta.styles = (valNode.elements || []).map((e) => {
+					const sv = stringValue(e, stringConsts);
+					return sv !== null ? sv : sourceCode.slice(e.start, e.end).replace(/['"`]/g, "");
+				});
+				else {
+					const sv = stringValue(valNode, stringConsts);
+					if (sv !== null) meta.styles = [sv];
+				}
+				break;
+			case "imports":
+			case "providers":
+			case "viewProviders":
+			case "animations":
+			case "rawImports":
+			case "declarations":
+			case "exports":
+			case "bootstrap":
+				if (valNode.type === "ArrayExpression") meta[key] = (valNode.elements || []).map((e) => new o.WrappedNodeExpr(unwrapForwardRefOxc(e)));
+				break;
+			case "useClass":
+			case "useExisting":
+			case "useValue": {
+				const unwrapped = unwrapForwardRefOxc(valNode);
+				const isForwardRef = valNode.type === "CallExpression" && unwrapped !== valNode;
+				meta[key] = {
+					expression: new o.WrappedNodeExpr(unwrapped),
+					forwardRef: isForwardRef ? 2 : 0
+				};
+				break;
+			}
+			case "useFactory":
+				meta[key] = new o.WrappedNodeExpr(valNode);
+				break;
+			case "hostDirectives":
+				if (valNode.type === "ArrayExpression") meta.hostDirectives = (valNode.elements || []).map((el) => {
+					if (el.type === "Identifier" || el.type === "CallExpression") {
+						const unwrapped = unwrapForwardRefOxc(el);
+						return {
+							directive: {
+								value: new o.WrappedNodeExpr(unwrapped),
+								type: new o.WrappedNodeExpr(unwrapped)
+							},
+							isForwardReference: el.type === "CallExpression",
+							inputs: null,
+							outputs: null
+						};
+					}
+					if (el.type === "ObjectExpression") {
+						let directiveNode = null;
+						let isForwardRef = false;
+						let inputs = null;
+						let outputs = null;
+						for (const prop of el.properties || []) {
+							if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+							const pName = propKeyName(prop);
+							if (pName === "directive") {
+								directiveNode = unwrapForwardRefOxc(prop.value);
+								isForwardRef = prop.value?.type === "CallExpression" && sourceCode.slice(prop.value.start, prop.value.end).includes("forwardRef");
+							} else if (pName === "inputs" && prop.value?.type === "ArrayExpression") {
+								inputs = {};
+								for (const e of prop.value.elements || []) {
+									const sv = stringValue(e);
+									if (sv !== null) {
+										const [source, alias = source] = sv.split(":").map((part) => part.trim());
+										if (source) inputs[source] = alias;
+									}
+								}
+							} else if (pName === "outputs" && prop.value?.type === "ArrayExpression") {
+								outputs = {};
+								for (const e of prop.value.elements || []) {
+									const sv = stringValue(e);
+									if (sv !== null) {
+										const [source, alias = source] = sv.split(":").map((part) => part.trim());
+										if (source) outputs[source] = alias;
+									}
+								}
+							}
+						}
+						if (directiveNode) return {
+							directive: {
+								value: new o.WrappedNodeExpr(directiveNode),
+								type: new o.WrappedNodeExpr(directiveNode)
+							},
+							isForwardReference: isForwardRef,
+							inputs,
+							outputs
+						};
+					}
+					return null;
+				}).filter(Boolean);
+				break;
+			default: meta[key] = valText.replace(/['"`]/g, "");
+		}
+	}
+	return meta;
+}
+/**
+* Detect signal-based APIs on class members: input(), model(), output(),
+* viewChild(), contentChild(), viewChildren(), contentChildren().
+*/
+function detectSignals(classNode, sourceCode) {
+	const inputs = {}, outputs = {}, viewQueries = [], contentQueries = [];
+	const members = classNode.body?.body || [];
+	for (const m of members) {
+		if (m.type !== "PropertyDefinition" || !m.key?.name || !m.value || m.value.type !== "CallExpression") continue;
+		const name = m.key.name;
+		const signalCall = getCallApi(m.value);
+		if (!signalCall) continue;
+		const { api, required } = signalCall;
+		if (!SIGNAL_APIS.has(api)) continue;
+		const args = m.value.arguments || [];
+		if (api === "input") {
+			let transform = null;
+			let alias = null;
+			const optionsArg = required ? args[0] : args[1];
+			if (optionsArg?.type === "ObjectExpression") for (const prop of optionsArg.properties || []) {
+				if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+				const k = propKeyName(prop);
+				if (k === "transform") transform = new o.WrappedNodeExpr(prop.value);
+				else if (k === "alias") {
+					const sv = stringValue(prop.value);
+					if (sv !== null) alias = sv;
+				}
+			}
+			inputs[name] = {
+				classPropertyName: name,
+				bindingPropertyName: alias ?? name,
+				isSignal: true,
+				required,
+				transform
+			};
+		} else if (api === "model") {
+			let alias = null;
+			const optionsArg = required ? args[0] : args[1];
+			if (optionsArg?.type === "ObjectExpression") for (const prop of optionsArg.properties || []) {
+				if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+				if (propKeyName(prop) === "alias") {
+					const sv = stringValue(prop.value);
+					if (sv !== null) alias = sv;
+				}
+			}
+			inputs[name] = {
+				classPropertyName: name,
+				bindingPropertyName: alias ?? name,
+				isSignal: true
+			};
+			outputs[name] = (alias ?? name) + "Change";
+		} else if (api === "viewChild" || api === "viewChildren" || api === "contentChild" || api === "contentChildren") {
+			const isViewQuery = api === "viewChild" || api === "viewChildren";
+			const isChildrenQuery = api === "viewChildren" || api === "contentChildren";
+			const firstArg = args[0];
+			const sv = stringValue(firstArg);
+			let read = null;
+			let descendants = isViewQuery || !isChildrenQuery;
+			const optArg = args[1];
+			if (optArg?.type === "ObjectExpression") for (const prop of optArg.properties || []) {
+				if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+				const k = propKeyName(prop);
+				if (k === "read") read = new o.WrappedNodeExpr(unwrapForwardRefOxc(prop.value));
+				else if (k === "descendants") {
+					const t = prop.value?.type;
+					if (t === "BooleanLiteral" || t === "Literal" && typeof prop.value.value === "boolean") descendants = prop.value.value;
+				}
+			}
+			const query = {
+				propertyName: name,
+				predicate: sv !== null ? [sv] : {
+					forwardRef: 0,
+					expression: new o.WrappedNodeExpr(firstArg)
+				},
+				first: !isChildrenQuery,
+				descendants,
+				read,
+				static: false,
+				emitFlags: 0,
+				isSignal: true
+			};
+			if (isViewQuery) viewQueries.push(query);
+			else contentQueries.push(query);
+		} else if (api === "output" || api === "outputFromObservable") {
+			let alias = name;
+			const optArg = args[0];
+			if (optArg?.type === "ObjectExpression") {
+				for (const prop of optArg.properties || []) if ((prop.type === "ObjectProperty" || prop.type === "Property") && propKeyName(prop) === "alias") {
+					const sv = stringValue(prop.value);
+					if (sv !== null) alias = sv;
+				}
+			}
+			outputs[name] = alias;
+		}
+	}
+	return {
+		inputs,
+		outputs,
+		viewQueries,
+		contentQueries
+	};
+}
+/**
+* Detect decorator-based field metadata: @Input, @Output, @ViewChild,
+* @ContentChild, @ViewChildren, @ContentChildren, @HostBinding, @HostListener.
+*/
+function detectFieldDecorators(classNode, sourceCode) {
+	const inputs = {};
+	const outputs = {};
+	const viewQueries = [];
+	const contentQueries = [];
+	const hostProperties = {};
+	const hostListeners = {};
+	const members = classNode.body?.body || [];
+	for (const member of members) {
+		const decorators = member.decorators || [];
+		if (decorators.length === 0) continue;
+		const memberName = member.key?.name || "";
+		for (const dec of decorators) {
+			const expr = dec.expression;
+			if (!expr || expr.type !== "CallExpression") continue;
+			const decName = expr.callee?.name;
+			if (!decName) continue;
+			const args = expr.arguments || [];
+			switch (decName) {
+				case "Input": {
+					let bindingName = memberName;
+					let required = false;
+					let transformFunction = null;
+					if (args.length > 0) {
+						const arg = args[0];
+						const sv = stringValue(arg);
+						if (sv !== null) bindingName = sv;
+						else if (arg.type === "ObjectExpression") for (const prop of arg.properties || []) {
+							if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+							const k = propKeyName(prop);
+							if (k === "alias") {
+								const asv = stringValue(prop.value);
+								if (asv !== null) bindingName = asv;
+							}
+							if (k === "required") required = sourceCode.slice(prop.value.start, prop.value.end) === "true";
+							if (k === "transform") transformFunction = new o.WrappedNodeExpr(prop.value);
+						}
+					}
+					inputs[memberName] = {
+						classPropertyName: memberName,
+						bindingPropertyName: bindingName,
+						isSignal: false,
+						required,
+						transformFunction
+					};
+					break;
+				}
+				case "Output": {
+					const sv = args.length > 0 ? stringValue(args[0]) : null;
+					outputs[memberName] = sv !== null ? sv : memberName;
+					break;
+				}
+				case "ViewChild":
+				case "ViewChildren":
+				case "ContentChild":
+				case "ContentChildren": {
+					const isView = decName.startsWith("View");
+					const isFirst = decName === "ViewChild" || decName === "ContentChild";
+					let predicate = [memberName];
+					if (args.length > 0) {
+						const pred = args[0];
+						const sv = stringValue(pred);
+						if (sv !== null) predicate = [sv];
+						else predicate = {
+							forwardRef: 0,
+							expression: new o.WrappedNodeExpr(unwrapForwardRefOxc(pred))
+						};
+					}
+					let read = null;
+					let isStatic = false;
+					let descendants = isView || isFirst;
+					if (args.length > 1 && args[1]?.type === "ObjectExpression") for (const prop of args[1].properties || []) {
+						if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+						const k = propKeyName(prop);
+						if (k === "read") read = new o.WrappedNodeExpr(prop.value);
+						if (k === "static") isStatic = sourceCode.slice(prop.value.start, prop.value.end) === "true";
+						if (k === "descendants") descendants = sourceCode.slice(prop.value.start, prop.value.end) === "true";
+					}
+					const query = {
+						propertyName: memberName,
+						predicate,
+						first: isFirst,
+						descendants,
+						read,
+						static: isStatic,
+						emitFlags: 0,
+						isSignal: false
+					};
+					if (isView) viewQueries.push(query);
+					else contentQueries.push(query);
+					break;
+				}
+				case "HostBinding": {
+					const sv = args.length > 0 ? stringValue(args[0]) : null;
+					const target = sv !== null ? sv : memberName;
+					hostProperties[target] = memberName;
+					break;
+				}
+				case "HostListener": {
+					const sv = args.length > 0 ? stringValue(args[0]) : null;
+					if (sv !== null) {
+						const event = sv;
+						let handler = `${memberName}()`;
+						if (args.length > 1 && args[1]?.type === "ArrayExpression") handler = `${memberName}(${(args[1].elements || []).map((e) => stringValue(e)).filter((v) => v !== null).join(", ")})`;
+						hostListeners[event] = handler;
+					}
+					break;
+				}
+			}
+		}
+	}
+	return {
+		inputs,
+		outputs,
+		viewQueries,
+		contentQueries,
+		hostProperties,
+		hostListeners
+	};
+}
+/**
+* Analyze constructor parameters for dependency injection.
+* Returns:
+* - R3DependencyMetadata[] for normal constructors
+* - null if class extends another without own constructor (use inherited factory)
+* - 'invalid' if any parameter has a type-only import token
+*
+* Accepts an OXC ClassDeclaration node and the original source string.
+*/
+function extractConstructorDeps(classNode, sourceCode, typeOnlyImports) {
+	const hasSuper = (classNode.superClass ? [classNode.superClass] : []).length > 0;
+	const ctor = (classNode.body?.body || []).find((m) => m.type === "MethodDefinition" && m.kind === "constructor");
+	if (!ctor) return hasSuper ? null : [];
+	const params = ctor.value?.params?.items || ctor.value?.params || [];
+	const deps = [];
+	let invalid = false;
+	for (const param of params) {
+		let token = null;
+		let attributeNameType = null;
+		let host = false, optional = false, self = false, skipSelf = false;
+		const actualParam = param.type === "TSParameterProperty" ? param.parameter : param;
+		const typeAnn = actualParam?.typeAnnotation?.typeAnnotation ?? param?.typeAnnotation?.typeAnnotation;
+		if (typeAnn) {
+			if (typeAnn.type === "TSTypeReference" && typeAnn.typeName) token = typeAnn.typeName.name ?? sourceCode.slice(typeAnn.typeName.start, typeAnn.typeName.end);
+			else if (typeAnn.type === "TSUnionType") {
+				const nonNullTypes = (typeAnn.types || []).filter((t) => {
+					if (!t) return false;
+					if (t.type === "TSNullKeyword") return false;
+					if (t.type === "TSUndefinedKeyword") return false;
+					if (t.type === "TSVoidKeyword") return false;
+					if (t.type === "TSLiteralType" && (t.literal?.type === "NullLiteral" || t.literal?.type === "Literal" && t.literal.value === null)) return false;
+					return true;
+				});
+				if (nonNullTypes.length === 1 && nonNullTypes[0].type === "TSTypeReference" && nonNullTypes[0].typeName) {
+					const t = nonNullTypes[0];
+					token = t.typeName.name ?? sourceCode.slice(t.typeName.start, t.typeName.end);
+				} else {
+					invalid = true;
+					continue;
+				}
+			} else if (typeAnn.type === "TSIntersectionType") {
+				invalid = true;
+				continue;
+			}
+		}
+		const paramDecs = [...param.decorators || [], ...param.type === "TSParameterProperty" && actualParam?.decorators ? actualParam.decorators : []];
+		for (const dec of paramDecs) {
+			const expr = dec.expression;
+			if (!expr || expr.type !== "CallExpression") continue;
+			const decName = expr.callee?.name;
+			if (!decName) continue;
+			const args = expr.arguments || [];
+			switch (decName) {
+				case "Inject":
+					if (args.length > 0) {
+						const sv = stringValue(args[0]);
+						if (sv !== null) token = sv;
+						else {
+							const unwrapped = unwrapForwardRefOxc(args[0]);
+							token = sourceCode.slice(unwrapped.start, unwrapped.end);
+						}
+					}
+					break;
+				case "Optional":
+					optional = true;
+					break;
+				case "Self":
+					self = true;
+					break;
+				case "SkipSelf":
+					skipSelf = true;
+					break;
+				case "Host":
+					host = true;
+					break;
+				case "Attribute":
+					if (args.length > 0) {
+						const sv = stringValue(args[0]);
+						if (sv !== null) {
+							attributeNameType = new o.LiteralExpr(sv);
+							token = "";
+						}
+					}
+					break;
+			}
+		}
+		if (!token && !attributeNameType) {
+			invalid = true;
+			continue;
+		}
+		if (token && typeOnlyImports.has(token)) {
+			invalid = true;
+			continue;
+		}
+		deps.push({
+			token: token ? new o.WrappedNodeExpr(token) : new o.LiteralExpr(null),
+			attributeNameType,
+			host,
+			optional,
+			self,
+			skipSelf
+		});
+	}
+	return invalid ? "invalid" : deps;
+}
+//#endregion
+export { collectStringConstants, detectFieldDecorators, detectSignals, extractConstructorDeps, extractMetadata };
+
+//# sourceMappingURL=metadata.js.map