@analogjs/vite-plugin-angular 3.0.0-alpha.8 → 3.0.0-alpha.81

package/src/lib/compiler/resource-inliner.js

@@ -0,0 +1,230 @@
+import { extractInlineStyles as extractInlineStyles$1 } from "./style-ast.js";
+import * as fs from "node:fs";
+import * as path$1 from "node:path";
+import { parseSync } from "oxc-parser";
+import MagicString from "magic-string";
+//#region packages/vite-plugin-angular/src/lib/compiler/resource-inliner.ts
+/** Whether a node is an inline style value (string literal or single-quasi template). */
+function isInlineStyleValue(node) {
+	return node?.type === "Literal" && typeof node.value === "string" || node?.type === "TemplateLiteral" && node.quasis?.length === 1;
+}
+/** Count the elements of a `styles: [...]` array that {@link extractInlineStyles} would emit. */
+function countInlineStyleLiterals(arrayExpr) {
+	let count = 0;
+	for (const el of arrayExpr.elements ?? []) if (el?.type === "Literal" && typeof el.value === "string") count++;
+	else if (el?.type === "TemplateLiteral" && el.quasis?.length === 1) count++;
+	return count;
+}
+/**
+* Inline external templateUrl and styleUrl/styleUrls into the source code
+* using OXC parser for precise AST-based rewriting.
+*
+* Replaces:
+*   templateUrl: './file.html'  →  template: "...file contents..."
+*   styleUrl: './file.scss'     →  styles: ["...file contents..."]
+*   styleUrls: ['./a.scss']     →  styles: ["...contents..."]
+*
+* When the decorator already has a `styles: [...]` array, inlined CSS is
+* merged into that existing array instead of emitting a second `styles`
+* property (which would be a duplicate object literal key).
+*
+* Returns the modified source code plus the per-style-index extension map
+* (see {@link InlineResourceResult}).
+*/
+async function inlineResourceUrls(code, fileName) {
+	const styleExtensions = /* @__PURE__ */ new Map();
+	if (!code.includes("templateUrl") && !code.includes("styleUrl")) return {
+		code,
+		styleExtensions,
+		resourceDependencies: []
+	};
+	const { program } = parseSync(fileName, code);
+	const ms = new MagicString(code);
+	let changed = false;
+	const dir = path$1.dirname(fileName);
+	const plans = [];
+	for (const node of program.body) {
+		const decl = node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+		if (!decl || decl.type !== "ClassDeclaration") continue;
+		for (const dec of decl.decorators || []) {
+			const expr = dec.expression;
+			if (!expr || expr.type !== "CallExpression") continue;
+			if (expr.callee?.name !== "Component") continue;
+			const arg = expr.arguments?.[0];
+			if (!arg || arg.type !== "ObjectExpression") continue;
+			let existingStylesProp = null;
+			let existingStylesArray = null;
+			for (const prop of arg.properties) {
+				if (prop.type !== "Property") continue;
+				if ((prop.key?.name ?? prop.key?.value) === "styles") {
+					existingStylesProp = prop;
+					if (prop.value?.type === "ArrayExpression") existingStylesArray = prop.value;
+					break;
+				}
+			}
+			const existingInlineCount = existingStylesArray ? countInlineStyleLiterals(existingStylesArray) : isInlineStyleValue(existingStylesProp?.value) ? 1 : 0;
+			const resourceProps = [];
+			for (const prop of arg.properties) {
+				if (prop.type !== "Property") continue;
+				const key = prop.key?.name ?? prop.key?.value;
+				const val = prop.value;
+				if (key === "templateUrl" && val?.type === "Literal" && typeof val.value === "string") {
+					resourceProps.push({
+						kind: "templateUrl",
+						prop,
+						resolvedPath: path$1.resolve(dir, val.value)
+					});
+					continue;
+				}
+				if (key === "styleUrl" && val?.type === "Literal" && typeof val.value === "string") {
+					resourceProps.push({
+						kind: "styleUrl",
+						prop,
+						resolvedPath: path$1.resolve(dir, val.value)
+					});
+					continue;
+				}
+				if (key === "styleUrls" && val?.type === "ArrayExpression") {
+					const resolvedPaths = [];
+					for (const el of val.elements) if (el?.type === "Literal" && typeof el.value === "string") resolvedPaths.push(path$1.resolve(dir, el.value));
+					resourceProps.push({
+						kind: "styleUrls",
+						prop,
+						resolvedPaths
+					});
+				}
+			}
+			plans.push({
+				existingStylesProp,
+				existingStylesArray,
+				existingInlineCount,
+				resourceProps
+			});
+		}
+	}
+	const pathsToRead = /* @__PURE__ */ new Set();
+	for (const plan of plans) for (const rp of plan.resourceProps) if (rp.kind === "styleUrls") for (const p of rp.resolvedPaths) pathsToRead.add(p);
+	else pathsToRead.add(rp.resolvedPath);
+	const fileContents = /* @__PURE__ */ new Map();
+	await Promise.all([...pathsToRead].map(async (p) => {
+		fileContents.set(p, await fs.promises.readFile(p, "utf-8").catch(() => void 0));
+	}));
+	let flatStyleBase = 0;
+	for (const plan of plans) {
+		const { existingStylesProp, existingStylesArray, existingInlineCount } = plan;
+		const templateUrlRewrites = [];
+		const cssProps = [];
+		for (const rp of plan.resourceProps) if (rp.kind === "templateUrl") {
+			const content = fileContents.get(rp.resolvedPath);
+			if (content !== void 0) templateUrlRewrites.push({
+				prop: rp.prop,
+				content
+			});
+		} else if (rp.kind === "styleUrl") {
+			const content = fileContents.get(rp.resolvedPath);
+			if (content !== void 0) cssProps.push({
+				prop: rp.prop,
+				contents: [content],
+				extensions: [extensionOf(rp.resolvedPath)]
+			});
+		} else {
+			const contents = [];
+			const extensions = [];
+			let allRead = true;
+			for (const p of rp.resolvedPaths) {
+				const content = fileContents.get(p);
+				if (content === void 0) {
+					allRead = false;
+					break;
+				}
+				contents.push(content);
+				extensions.push(extensionOf(p));
+			}
+			if (allRead && contents.length > 0) cssProps.push({
+				prop: rp.prop,
+				contents,
+				extensions
+			});
+		}
+		for (const { prop, content } of templateUrlRewrites) {
+			ms.overwrite(prop.start, prop.end, `template: ${JSON.stringify(content)}`);
+			changed = true;
+		}
+		if (cssProps.length > 0) {
+			const allContents = cssProps.flatMap((c) => c.contents);
+			const allExtensions = cssProps.flatMap((c) => c.extensions);
+			if (existingStylesArray) {
+				const realElements = existingStylesArray.elements.filter((e) => e != null);
+				if (realElements.length > 0) {
+					const lastElement = realElements[realElements.length - 1];
+					const insertion = allContents.map((c) => `, ${JSON.stringify(c)}`).join("");
+					ms.appendRight(lastElement.end, insertion);
+				} else {
+					const insertion = allContents.map((c) => JSON.stringify(c)).join(", ");
+					ms.appendLeft(existingStylesArray.end - 1, insertion);
+				}
+				for (const { prop } of cssProps) removePropertyWithSeparator(ms, code, prop.start, prop.end);
+			} else if (isInlineStyleValue(existingStylesProp?.value)) {
+				const original = code.slice(existingStylesProp.value.start, existingStylesProp.value.end);
+				const merged = allContents.map((c) => `, ${JSON.stringify(c)}`).join("");
+				ms.overwrite(existingStylesProp.value.start, existingStylesProp.value.end, `[${original}${merged}]`);
+				for (const { prop } of cssProps) removePropertyWithSeparator(ms, code, prop.start, prop.end);
+			} else {
+				const [first, ...rest] = cssProps;
+				ms.overwrite(first.prop.start, first.prop.end, `styles: [${allContents.map((c) => JSON.stringify(c)).join(", ")}]`);
+				for (const { prop } of rest) removePropertyWithSeparator(ms, code, prop.start, prop.end);
+			}
+			changed = true;
+			const externalBase = flatStyleBase + existingInlineCount;
+			allExtensions.forEach((ext, k) => {
+				if (ext) styleExtensions.set(externalBase + k, ext);
+			});
+			flatStyleBase = externalBase + allContents.length;
+		} else flatStyleBase += existingInlineCount;
+	}
+	return {
+		code: changed ? ms.toString() : code,
+		styleExtensions,
+		resourceDependencies: [...pathsToRead].filter((p) => fileContents.get(p) !== void 0)
+	};
+}
+/** Lower-cased file extension without the leading dot (e.g. `scss`), or `''`. */
+function extensionOf(filePath) {
+	return path$1.extname(filePath).slice(1).toLowerCase();
+}
+/**
+* Remove a property from an object literal while also eating one surrounding
+* comma so the resulting object stays syntactically valid. Prefers the
+* trailing comma; falls back to the leading comma when the property is the
+* last entry in the object.
+*/
+function removePropertyWithSeparator(ms, code, propStart, propEnd) {
+	let i = propEnd;
+	while (i < code.length && isWhitespace(code[i])) i++;
+	if (code[i] === ",") {
+		ms.remove(propStart, i + 1);
+		return;
+	}
+	let j = propStart - 1;
+	while (j >= 0 && isWhitespace(code[j])) j--;
+	if (code[j] === ",") {
+		ms.remove(j, propEnd);
+		return;
+	}
+	ms.remove(propStart, propEnd);
+}
+function isWhitespace(ch) {
+	return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+}
+/**
+* Extract inline style strings from Angular @Component decorator using OXC parser.
+* Returns an array of style string values for preprocessing.
+*/
+function extractInlineStyles(code, fileName, program) {
+	if (!code.includes("styles")) return [];
+	return extractInlineStyles$1(code, fileName, program);
+}
+//#endregion
+export { extractInlineStyles, inlineResourceUrls };
+
+//# sourceMappingURL=resource-inliner.js.map

package/src/lib/compiler/resource-inliner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-inliner.js","names":[],"sources":["../../../../src/lib/compiler/resource-inliner.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport { parseSync } from 'oxc-parser';\nimport MagicString from 'magic-string';\nimport { extractInlineStyles as extractStylesFromAst } from './style-ast.js';\n\nexport interface InlineResourceResult {\n  /** The modified source code, or the original if no changes were needed. */\n  code: string;\n  /**\n   * Source extension (without the leading dot, lower-cased — e.g. `scss`) of\n   * each inlined external style, keyed by its position in the flat per-file\n   * style list produced by {@link extractInlineStyles}. Lets the caller run\n   * each external `styleUrl` through the right preprocessor by its own file\n   * extension, independent of the `inlineStylesExtension` option (which governs\n   * truly-inline `styles: [...]` template strings).\n   */\n  styleExtensions: Map<number, string>;\n  /**\n   * Absolute paths of every external resource file successfully read and\n   * inlined. Callers record these so a later edit to the resource file can\n   * invalidate the owning source module — the inlined copy is otherwise\n   * invisible to the module graph.\n   */\n  resourceDependencies: string[];\n}\n\n/** Whether a node is an inline style value (string literal or single-quasi template). */\nfunction isInlineStyleValue(node: any): boolean {\n  return (\n    (node?.type === 'Literal' && typeof node.value === 'string') ||\n    (node?.type === 'TemplateLiteral' && node.quasis?.length === 1)\n  );\n}\n\n/** Count the elements of a `styles: [...]` array that {@link extractInlineStyles} would emit. */\nfunction countInlineStyleLiterals(arrayExpr: any): number {\n  let count = 0;\n  for (const el of arrayExpr.elements ?? []) {\n    if (el?.type === 'Literal' && typeof el.value === 'string') count++;\n    else if (el?.type === 'TemplateLiteral' && el.quasis?.length === 1) count++;\n  }\n  return count;\n}\n\n/**\n * Inline external templateUrl and styleUrl/styleUrls into the source code\n * using OXC parser for precise AST-based rewriting.\n *\n * Replaces:\n *   templateUrl: './file.html'  →  template: \"...file contents...\"\n *   styleUrl: './file.scss'     →  styles: [\"...file contents...\"]\n *   styleUrls: ['./a.scss']     →  styles: [\"...contents...\"]\n *\n * When the decorator already has a `styles: [...]` array, inlined CSS is\n * merged into that existing array instead of emitting a second `styles`\n * property (which would be a duplicate object literal key).\n *\n * Returns the modified source code plus the per-style-index extension map\n * (see {@link InlineResourceResult}).\n */\nexport async function inlineResourceUrls(\n  code: string,\n  fileName: string,\n): Promise<InlineResourceResult> {\n  const styleExtensions = new Map<number, string>();\n\n  if (!code.includes('templateUrl') && !code.includes('styleUrl')) {\n    return { code, styleExtensions, resourceDependencies: [] };\n  }\n\n  const { program } = parseSync(fileName, code);\n  const ms = new MagicString(code);\n  let changed = false;\n  const dir = path.dirname(fileName);\n\n  // Phase 1: walk the AST and collect resource descriptors per decorator,\n  // in source order — no I/O during the walk. A plan is recorded for every\n  // `@Component` decorator (even without url props) because the flat style\n  // index bookkeeping below advances per decorator.\n  type ResourceProp =\n    | { kind: 'templateUrl'; prop: any; resolvedPath: string }\n    | { kind: 'styleUrl'; prop: any; resolvedPath: string }\n    | { kind: 'styleUrls'; prop: any; resolvedPaths: string[] };\n  interface DecoratorPlan {\n    existingStylesProp: any;\n    existingStylesArray: any;\n    existingInlineCount: number;\n    resourceProps: ResourceProp[];\n  }\n  const plans: DecoratorPlan[] = [];\n\n  for (const node of program.body) {\n    const decl =\n      node.type === 'ExportNamedDeclaration' ||\n      node.type === 'ExportDefaultDeclaration'\n        ? (node as any).declaration\n        : node;\n    if (!decl || decl.type !== 'ClassDeclaration') continue;\n\n    for (const dec of decl.decorators || []) {\n      const expr = dec.expression;\n      if (!expr || expr.type !== 'CallExpression') continue;\n      if (expr.callee?.name !== 'Component') continue;\n\n      const arg = expr.arguments?.[0];\n      if (!arg || arg.type !== 'ObjectExpression') continue;\n\n      // First pass: locate an existing `styles` property in the same decorator.\n      // Inlined CSS is merged into it — converting a singular string/template\n      // value to an array when needed — to avoid emitting a duplicate `styles`\n      // key.\n      let existingStylesProp: any = null;\n      let existingStylesArray: any = null;\n      for (const prop of arg.properties) {\n        if (prop.type !== 'Property') continue;\n        const key: string = prop.key?.name ?? prop.key?.value;\n        if (key === 'styles') {\n          existingStylesProp = prop;\n          if (prop.value?.type === 'ArrayExpression') {\n            existingStylesArray = prop.value;\n          }\n          break;\n        }\n      }\n\n      // Inline `styles` entries already present come first in the flat list;\n      // appended external styles follow them.\n      const existingInlineCount = existingStylesArray\n        ? countInlineStyleLiterals(existingStylesArray)\n        : isInlineStyleValue(existingStylesProp?.value)\n          ? 1\n          : 0;\n\n      const resourceProps: ResourceProp[] = [];\n\n      for (const prop of arg.properties) {\n        if (prop.type !== 'Property') continue;\n        const key: string = prop.key?.name ?? prop.key?.value;\n        const val = prop.value;\n\n        if (\n          key === 'templateUrl' &&\n          val?.type === 'Literal' &&\n          typeof val.value === 'string'\n        ) {\n          resourceProps.push({\n            kind: 'templateUrl',\n            prop,\n            resolvedPath: path.resolve(dir, val.value),\n          });\n          continue;\n        }\n\n        if (\n          key === 'styleUrl' &&\n          val?.type === 'Literal' &&\n          typeof val.value === 'string'\n        ) {\n          resourceProps.push({\n            kind: 'styleUrl',\n            prop,\n            resolvedPath: path.resolve(dir, val.value),\n          });\n          continue;\n        }\n\n        if (key === 'styleUrls' && val?.type === 'ArrayExpression') {\n          const resolvedPaths: string[] = [];\n          for (const el of val.elements) {\n            if (el?.type === 'Literal' && typeof el.value === 'string') {\n              resolvedPaths.push(path.resolve(dir, el.value));\n            }\n          }\n          resourceProps.push({ kind: 'styleUrls', prop, resolvedPaths });\n        }\n      }\n\n      plans.push({\n        existingStylesProp,\n        existingStylesArray,\n        existingInlineCount,\n        resourceProps,\n      });\n    }\n  }\n\n  // Phase 2: read every referenced resource without blocking the event\n  // loop. Each read catches its own failure to `undefined` — one missing\n  // file must not abort sibling reads that succeed.\n  const pathsToRead = new Set<string>();\n  for (const plan of plans) {\n    for (const rp of plan.resourceProps) {\n      if (rp.kind === 'styleUrls') {\n        for (const p of rp.resolvedPaths) pathsToRead.add(p);\n      } else {\n        pathsToRead.add(rp.resolvedPath);\n      }\n    }\n  }\n  const fileContents = new Map<string, string | undefined>();\n  await Promise.all(\n    [...pathsToRead].map(async (p) => {\n      fileContents.set(\n        p,\n        await fs.promises.readFile(p, 'utf-8').catch(() => undefined),\n      );\n    }),\n  );\n\n  // Phase 3: apply MagicString rewrites in the original AST order so the\n  // flat style index bookkeeping matches `extractInlineStyles`.\n\n  // Running base index into the flat per-file style list (matching the order\n  // `extractInlineStyles` walks classes/decorators/properties) so external\n  // styles can be mapped to the index `resolvedInlineStyles` later keys on.\n  let flatStyleBase = 0;\n\n  for (const plan of plans) {\n    const { existingStylesProp, existingStylesArray, existingInlineCount } =\n      plan;\n\n    // Collect the props we want to rewrite. Contents from styleUrl /\n    // styleUrls are accumulated so that multiple url-based props in one\n    // decorator collapse into a single `styles` array write. `extensions`\n    // tracks each content's source extension in the same order.\n    const templateUrlRewrites: Array<{ prop: any; content: string }> = [];\n    const cssProps: Array<{\n      prop: any;\n      contents: string[];\n      extensions: string[];\n    }> = [];\n\n    for (const rp of plan.resourceProps) {\n      if (rp.kind === 'templateUrl') {\n        // Keep original if file can't be read\n        const content = fileContents.get(rp.resolvedPath);\n        if (content !== undefined) {\n          templateUrlRewrites.push({ prop: rp.prop, content });\n        }\n      } else if (rp.kind === 'styleUrl') {\n        // Keep original if file can't be read\n        const content = fileContents.get(rp.resolvedPath);\n        if (content !== undefined) {\n          cssProps.push({\n            prop: rp.prop,\n            contents: [content],\n            extensions: [extensionOf(rp.resolvedPath)],\n          });\n        }\n      } else {\n        // styleUrls is all-or-nothing: keep the original property if any\n        // entry failed to read.\n        const contents: string[] = [];\n        const extensions: string[] = [];\n        let allRead = true;\n        for (const p of rp.resolvedPaths) {\n          const content = fileContents.get(p);\n          if (content === undefined) {\n            allRead = false;\n            break;\n          }\n          contents.push(content);\n          extensions.push(extensionOf(p));\n        }\n        if (allRead && contents.length > 0) {\n          cssProps.push({ prop: rp.prop, contents, extensions });\n        }\n      }\n    }\n\n    for (const { prop, content } of templateUrlRewrites) {\n      ms.overwrite(\n        prop.start,\n        prop.end,\n        `template: ${JSON.stringify(content)}`,\n      );\n      changed = true;\n    }\n\n    if (cssProps.length > 0) {\n      const allContents = cssProps.flatMap((c) => c.contents);\n      const allExtensions = cssProps.flatMap((c) => c.extensions);\n\n      if (existingStylesArray) {\n        // Filter out null holes in case the source already has a sparse array.\n        const realElements = (existingStylesArray.elements as any[]).filter(\n          (e) => e != null,\n        );\n\n        if (realElements.length > 0) {\n          // Insert right after the last real element. This preserves any\n          // trailing comma the source may have (e.g. Prettier output) and\n          // avoids producing a sparse `[existing, , \"new\"]` element, which\n          // would crash downstream decorator metadata extraction.\n          const lastElement = realElements[realElements.length - 1];\n          const insertion = allContents\n            .map((c) => `, ${JSON.stringify(c)}`)\n            .join('');\n          ms.appendRight(lastElement.end, insertion);\n        } else {\n          // Empty array — drop the leading comma.\n          const insertion = allContents\n            .map((c) => JSON.stringify(c))\n            .join(', ');\n          ms.appendLeft(existingStylesArray.end - 1, insertion);\n        }\n\n        for (const { prop } of cssProps) {\n          removePropertyWithSeparator(ms, code, prop.start, prop.end);\n        }\n      } else if (isInlineStyleValue(existingStylesProp?.value)) {\n        // Singular `styles: '...'` / `styles: \\`...\\`` — wrap the original\n        // value into an array merged with the inlined styles, then drop the\n        // styleUrl props so only one `styles` key remains.\n        const original = code.slice(\n          existingStylesProp.value.start,\n          existingStylesProp.value.end,\n        );\n        const merged = allContents\n          .map((c) => `, ${JSON.stringify(c)}`)\n          .join('');\n        ms.overwrite(\n          existingStylesProp.value.start,\n          existingStylesProp.value.end,\n          `[${original}${merged}]`,\n        );\n        for (const { prop } of cssProps) {\n          removePropertyWithSeparator(ms, code, prop.start, prop.end);\n        }\n      } else {\n        // No existing `styles` array — rewrite the first styleUrl/styleUrls\n        // prop with the merged contents and drop any additional ones so we\n        // don't emit multiple `styles` properties.\n        const [first, ...rest] = cssProps;\n        ms.overwrite(\n          first.prop.start,\n          first.prop.end,\n          `styles: [${allContents.map((c) => JSON.stringify(c)).join(', ')}]`,\n        );\n        for (const { prop } of rest) {\n          removePropertyWithSeparator(ms, code, prop.start, prop.end);\n        }\n      }\n      changed = true;\n\n      // The appended external styles occupy the flat indices after any\n      // pre-existing inline styles for this component.\n      const externalBase = flatStyleBase + existingInlineCount;\n      allExtensions.forEach((ext, k) => {\n        if (ext) styleExtensions.set(externalBase + k, ext);\n      });\n      flatStyleBase = externalBase + allContents.length;\n    } else {\n      flatStyleBase += existingInlineCount;\n    }\n  }\n\n  return {\n    code: changed ? ms.toString() : code,\n    styleExtensions,\n    resourceDependencies: [...pathsToRead].filter(\n      (p) => fileContents.get(p) !== undefined,\n    ),\n  };\n}\n\n/** Lower-cased file extension without the leading dot (e.g. `scss`), or `''`. */\nfunction extensionOf(filePath: string): string {\n  return path.extname(filePath).slice(1).toLowerCase();\n}\n\n/**\n * Remove a property from an object literal while also eating one surrounding\n * comma so the resulting object stays syntactically valid. Prefers the\n * trailing comma; falls back to the leading comma when the property is the\n * last entry in the object.\n */\nfunction removePropertyWithSeparator(\n  ms: MagicString,\n  code: string,\n  propStart: number,\n  propEnd: number,\n): void {\n  let i = propEnd;\n  while (i < code.length && isWhitespace(code[i])) i++;\n  if (code[i] === ',') {\n    ms.remove(propStart, i + 1);\n    return;\n  }\n  let j = propStart - 1;\n  while (j >= 0 && isWhitespace(code[j])) j--;\n  if (code[j] === ',') {\n    ms.remove(j, propEnd);\n    return;\n  }\n  ms.remove(propStart, propEnd);\n}\n\nfunction isWhitespace(ch: string): boolean {\n  return (\n    ch === ' ' ||\n    ch === '\\t' ||\n    ch === '\\n' ||\n    ch === '\\r' ||\n    ch === '\\f' ||\n    ch === '\\v'\n  );\n}\n\n/**\n * Extract inline style strings from Angular @Component decorator using OXC parser.\n * Returns an array of style string values for preprocessing.\n */\nexport function extractInlineStyles(\n  code: string,\n  fileName: string,\n  program?: ReturnType<typeof parseSync>['program'],\n): string[] {\n  if (!code.includes('styles')) return [];\n  return extractStylesFromAst(code, fileName, program);\n}\n"],"mappings":"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"}

package/src/lib/compiler/style-ast.d.ts

@@ -0,0 +1,9 @@
+import { parseSync } from "oxc-parser";
+/**
+* Extract styleUrl/styleUrls values from Angular @Component decorators.
+*/
+export declare function extractStyleUrls(code: string, fileName: string): string[];
+/**
+* Extract inline style strings from Angular @Component decorators.
+*/
+export declare function extractInlineStyles(code: string, fileName: string, program?: ReturnType<typeof parseSync>["program"]): string[];

package/src/lib/compiler/style-ast.js

@@ -0,0 +1,54 @@
+import { parseSync } from "oxc-parser";
+//#region packages/vite-plugin-angular/src/lib/compiler/style-ast.ts
+function getClassDeclaration(node) {
+	return node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+}
+function getPropertyKey(prop) {
+	return prop.key?.name || prop.key?.value;
+}
+function getTemplateLiteralText(node) {
+	if (node?.type !== "TemplateLiteral" || node.quasis?.length !== 1) return;
+	return node.quasis[0].value.cooked || node.quasis[0].value.raw;
+}
+/**
+* Extract inline style strings from Angular @Component decorators.
+*/
+function extractInlineStyles(code, fileName, program) {
+	const styles = [];
+	program ??= parseSync(fileName, code).program;
+	for (const node of program.body) {
+		const decl = getClassDeclaration(node);
+		if (!decl || decl.type !== "ClassDeclaration") continue;
+		for (const dec of decl.decorators || []) {
+			const expr = dec.expression;
+			if (!expr || expr.type !== "CallExpression") continue;
+			if (expr.callee?.name !== "Component") continue;
+			const arg = expr.arguments?.[0];
+			if (!arg || arg.type !== "ObjectExpression") continue;
+			for (const prop of arg.properties) {
+				if (prop.type !== "Property") continue;
+				const key = getPropertyKey(prop);
+				const val = prop.value;
+				if (key !== "styles") continue;
+				if (val?.type === "ArrayExpression") for (const el of val.elements) {
+					if (el?.type === "Literal" && typeof el.value === "string") {
+						styles.push(el.value);
+						continue;
+					}
+					const templateText = getTemplateLiteralText(el);
+					if (templateText !== void 0) styles.push(templateText);
+				}
+				else if (val?.type === "Literal" && typeof val.value === "string") styles.push(val.value);
+				else {
+					const templateText = getTemplateLiteralText(val);
+					if (templateText !== void 0) styles.push(templateText);
+				}
+			}
+		}
+	}
+	return styles;
+}
+//#endregion
+export { extractInlineStyles };
+
+//# sourceMappingURL=style-ast.js.map

package/src/lib/compiler/style-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-ast.js","names":[],"sources":["../../../../src/lib/compiler/style-ast.ts"],"sourcesContent":["import { parseSync } from 'oxc-parser';\n\ntype ProgramNode = ReturnType<typeof parseSync>['program']['body'][number];\n\nfunction getClassDeclaration(node: ProgramNode): any {\n  return node.type === 'ExportNamedDeclaration' ||\n    node.type === 'ExportDefaultDeclaration'\n    ? (node as any).declaration\n    : node;\n}\n\nfunction getPropertyKey(prop: any): string | undefined {\n  return prop.key?.name || prop.key?.value;\n}\n\nfunction getTemplateLiteralText(node: any): string | undefined {\n  if (node?.type !== 'TemplateLiteral' || node.quasis?.length !== 1) {\n    return undefined;\n  }\n\n  return node.quasis[0].value.cooked || node.quasis[0].value.raw;\n}\n\n/**\n * Extract styleUrl/styleUrls values from Angular @Component decorators.\n */\nexport function extractStyleUrls(code: string, fileName: string): string[] {\n  const urls: string[] = [];\n  const { program } = parseSync(fileName, code);\n\n  for (const node of program.body) {\n    const decl = getClassDeclaration(node);\n    if (!decl || decl.type !== 'ClassDeclaration') continue;\n\n    for (const dec of decl.decorators || []) {\n      const expr = dec.expression;\n      if (!expr || expr.type !== 'CallExpression') continue;\n      if (expr.callee?.name !== 'Component') continue;\n\n      const arg = expr.arguments?.[0];\n      if (!arg || arg.type !== 'ObjectExpression') continue;\n\n      for (const prop of arg.properties) {\n        if (prop.type !== 'Property') continue;\n        const key = getPropertyKey(prop);\n        const val = prop.value;\n\n        if (\n          key === 'styleUrl' &&\n          val?.type === 'Literal' &&\n          typeof val.value === 'string'\n        ) {\n          urls.push(val.value);\n        }\n\n        if (key === 'styleUrls' && val?.type === 'ArrayExpression') {\n          for (const el of val.elements) {\n            if (el?.type === 'Literal' && typeof el.value === 'string') {\n              urls.push(el.value);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return urls;\n}\n\n/**\n * Extract inline style strings from Angular @Component decorators.\n */\nexport function extractInlineStyles(\n  code: string,\n  fileName: string,\n  program?: ReturnType<typeof parseSync>['program'],\n): string[] {\n  const styles: string[] = [];\n  program ??= parseSync(fileName, code).program;\n\n  for (const node of program.body) {\n    const decl = getClassDeclaration(node);\n    if (!decl || decl.type !== 'ClassDeclaration') continue;\n\n    for (const dec of decl.decorators || []) {\n      const expr = dec.expression;\n      if (!expr || expr.type !== 'CallExpression') continue;\n      if (expr.callee?.name !== 'Component') continue;\n\n      const arg = expr.arguments?.[0];\n      if (!arg || arg.type !== 'ObjectExpression') continue;\n\n      for (const prop of arg.properties) {\n        if (prop.type !== 'Property') continue;\n        const key = getPropertyKey(prop);\n        const val = prop.value;\n\n        if (key !== 'styles') continue;\n\n        if (val?.type === 'ArrayExpression') {\n          for (const el of val.elements) {\n            if (el?.type === 'Literal' && typeof el.value === 'string') {\n              styles.push(el.value);\n              continue;\n            }\n\n            const templateText = getTemplateLiteralText(el);\n            if (templateText !== undefined) {\n              styles.push(templateText);\n            }\n          }\n        } else if (val?.type === 'Literal' && typeof val.value === 'string') {\n          styles.push(val.value);\n        } else {\n          const templateText = getTemplateLiteralText(val);\n          if (templateText !== undefined) {\n            styles.push(templateText);\n          }\n        }\n      }\n    }\n  }\n\n  return styles;\n}\n"],"mappings":";;AAIA,SAAS,oBAAoB,MAAwB;AACnD,QAAO,KAAK,SAAS,4BACnB,KAAK,SAAS,6BACX,KAAa,cACd;;AAGN,SAAS,eAAe,MAA+B;AACrD,QAAO,KAAK,KAAK,QAAQ,KAAK,KAAK;;AAGrC,SAAS,uBAAuB,MAA+B;AAC7D,KAAI,MAAM,SAAS,qBAAqB,KAAK,QAAQ,WAAW,EAC9D;AAGF,QAAO,KAAK,OAAO,GAAG,MAAM,UAAU,KAAK,OAAO,GAAG,MAAM;;;;;AAoD7D,SAAgB,oBACd,MACA,UACA,SACU;CACV,MAAM,SAAmB,EAAE;AAC3B,aAAY,UAAU,UAAU,KAAK,CAAC;AAEtC,MAAK,MAAM,QAAQ,QAAQ,MAAM;EAC/B,MAAM,OAAO,oBAAoB,KAAK;AACtC,MAAI,CAAC,QAAQ,KAAK,SAAS,mBAAoB;AAE/C,OAAK,MAAM,OAAO,KAAK,cAAc,EAAE,EAAE;GACvC,MAAM,OAAO,IAAI;AACjB,OAAI,CAAC,QAAQ,KAAK,SAAS,iBAAkB;AAC7C,OAAI,KAAK,QAAQ,SAAS,YAAa;GAEvC,MAAM,MAAM,KAAK,YAAY;AAC7B,OAAI,CAAC,OAAO,IAAI,SAAS,mBAAoB;AAE7C,QAAK,MAAM,QAAQ,IAAI,YAAY;AACjC,QAAI,KAAK,SAAS,WAAY;IAC9B,MAAM,MAAM,eAAe,KAAK;IAChC,MAAM,MAAM,KAAK;AAEjB,QAAI,QAAQ,SAAU;AAEtB,QAAI,KAAK,SAAS,kBAChB,MAAK,MAAM,MAAM,IAAI,UAAU;AAC7B,SAAI,IAAI,SAAS,aAAa,OAAO,GAAG,UAAU,UAAU;AAC1D,aAAO,KAAK,GAAG,MAAM;AACrB;;KAGF,MAAM,eAAe,uBAAuB,GAAG;AAC/C,SAAI,iBAAiB,KAAA,EACnB,QAAO,KAAK,aAAa;;aAGpB,KAAK,SAAS,aAAa,OAAO,IAAI,UAAU,SACzD,QAAO,KAAK,IAAI,MAAM;SACjB;KACL,MAAM,eAAe,uBAAuB,IAAI;AAChD,SAAI,iBAAiB,KAAA,EACnB,QAAO,KAAK,aAAa;;;;;AAOnC,QAAO"}

package/src/lib/compiler/styles.d.ts

@@ -0,0 +1,13 @@
+import { type ResolvedConfig } from "vite";
+/**
+* Extract styleUrl/styleUrls from source using OXC parser,
+* read and preprocess them via Vite.
+* Returns a Map of absolute path → compiled CSS for the compiler to use.
+*/
+export declare function resolveStyleFiles(code: string, id: string, resolvedConfig: ResolvedConfig): Promise<Map<string, string> | undefined>;
+/**
+* Preprocess inline styles that contain SCSS/Sass syntax.
+* Uses OXC parser to extract style strings from decorator arguments
+* and runs them through Vite's preprocessCSS.
+*/
+export declare function preprocessInlineStyles(code: string, id: string, inlineStyleLanguage: string, resolvedConfig: ResolvedConfig): Promise<Map<number, string> | undefined>;

package/src/lib/compiler/test-helpers.d.ts

@@ -0,0 +1,7 @@
+import { ComponentRegistry } from "./registry";
+export declare function buildRegistry(files: Record<string, string>): ComponentRegistry;
+/** Convenience wrapper: compile and return just the code string. */
+export declare function compileCode(sourceCode: string, fileName: string, registry?: ComponentRegistry): string;
+/** Compile in partial mode and return just the code string. */
+export declare function compilePartialCode(sourceCode: string, fileName: string, registry?: ComponentRegistry): string;
+export declare function expectCompiles(result: string);

package/src/lib/compiler/type-elision.d.ts

@@ -0,0 +1,28 @@
+import MagicString from "magic-string";
+import { parseSync } from "oxc-parser";
+/**
+* Analyse compiled TypeScript source and return the set of imported names
+* that are only referenced in type positions (type annotations, implements
+* clauses, generics, etc.) and can safely be elided.
+*
+* Uses oxc-parser for fast, Rust-based AST analysis — no type-checker needed.
+*/
+export declare function detectTypeOnlyImportNames(code: string, program?: ReturnType<typeof parseSync>["program"]): Set<string>;
+/**
+* Elide import specifiers (or entire import declarations) for names that are
+* only used in type positions. Operates on the compiler's TypeScript output
+* (before OXC strips remaining TS syntax).
+*
+* Returns the modified source code, or the original if nothing was elided.
+*/
+export declare function elideTypeOnlyImports(code: string): string;
+/**
+* Elide type-only imports directly on a MagicString instance, so that
+* subsequent `ms.generateMap()` calls produce an accurate sourcemap.
+*
+* Detects type-only names from `ms.toString()` (the fully-mutated code),
+* but reads import positions from `ms.original` (the coordinate system
+* MagicString expects). `originalProgram`, when provided, must be a parse
+* of `ms.original` — never of the mutated text.
+*/
+export declare function elideTypeOnlyImportsMagicString(ms: MagicString, originalProgram?: ReturnType<typeof parseSync>["program"]): void;

package/src/lib/compiler/type-elision.js

@@ -0,0 +1,211 @@
+import { parseSync } from "oxc-parser";
+import "magic-string";
+//#region packages/vite-plugin-angular/src/lib/compiler/type-elision.ts
+/**
+* AST property keys that represent type-only positions in TypeScript.
+* Identifiers found only under these keys are never emitted as runtime values.
+*/
+var TYPE_POSITION_KEYS = new Set([
+	"typeAnnotation",
+	"typeParameters",
+	"superTypeParameters",
+	"implements",
+	"returnType",
+	"typeArguments"
+]);
+/**
+* AST node types that represent type-level constructs.
+* Any identifier nested inside one of these nodes is in a type position.
+*/
+var TYPE_NODE_TYPES = new Set([
+	"TSTypeAnnotation",
+	"TSTypeReference",
+	"TSTypeParameterInstantiation",
+	"TSTypeParameterDeclaration",
+	"TSInterfaceDeclaration",
+	"TSTypeAliasDeclaration",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSUnionType",
+	"TSIntersectionType",
+	"TSArrayType",
+	"TSTupleType",
+	"TSFunctionType",
+	"TSConstructorType",
+	"TSMappedType",
+	"TSConditionalType",
+	"TSIndexedAccessType",
+	"TSTypeQuery",
+	"TSTypeLiteral",
+	"TSQualifiedName",
+	"TSInterfaceBody"
+]);
+/**
+* Internal helper: parse code and return both the AST and the set of
+* type-only imported names. Avoids double-parsing when both are needed.
+*/
+function analyzeTypeOnlyImports(code, program) {
+	const ast = program ?? parseSync("file.ts", code).program;
+	const importedNames = /* @__PURE__ */ new Set();
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.importKind === "type") continue;
+		for (const spec of node.specifiers ?? []) {
+			if (spec.importKind === "type") continue;
+			importedNames.add(spec.local.name);
+		}
+	}
+	if (importedNames.size === 0) return {
+		ast,
+		typeOnlyNames: /* @__PURE__ */ new Set()
+	};
+	const valueReferenced = /* @__PURE__ */ new Set();
+	collectConstructorDiTokens(ast, importedNames, valueReferenced);
+	function walk(node, inTypePosition) {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const item of node) walk(item, inTypePosition);
+			return;
+		}
+		if (valueReferenced.size === importedNames.size) return;
+		if (!inTypePosition && TYPE_NODE_TYPES.has(node.type)) {
+			if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+				walk(node.expression, false);
+				walk(node.typeAnnotation, true);
+				return;
+			}
+			inTypePosition = true;
+		}
+		if (!inTypePosition && node.type === "ExportNamedDeclaration" && !node.source) {
+			if (node.declaration) walk(node.declaration, false);
+			for (const spec of node.specifiers ?? []) {
+				if (node.exportKind === "type" || spec.exportKind === "type") continue;
+				walk(spec, false);
+			}
+			return;
+		}
+		if (!inTypePosition && node.type === "Identifier" && importedNames.has(node.name)) {
+			valueReferenced.add(node.name);
+			return;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "type" || key === "start" || key === "end" || key === "range" || key === "loc") continue;
+			const isTypePos = inTypePosition || TYPE_POSITION_KEYS.has(key);
+			walk(node[key], isTypePos);
+		}
+	}
+	for (const node of ast.body) if (node.type !== "ImportDeclaration") walk(node, false);
+	const typeOnly = /* @__PURE__ */ new Set();
+	for (const name of importedNames) if (!valueReferenced.has(name)) typeOnly.add(name);
+	return {
+		ast,
+		typeOnlyNames: typeOnly
+	};
+}
+/**
+* Walk the program looking for decorated classes with constructors and add
+* the type names from constructor parameter annotations to `valueReferenced`.
+*
+* Constructor parameter types are TypeScript type positions, but for decorated
+* classes they double as runtime DI tokens — Angular's compiler reads them
+* via `compileFactoryFunction` to wire `ɵɵdirectiveInject(...)` calls. The
+* import of the type therefore must NOT be elided as type-only.
+*/
+function collectConstructorDiTokens(ast, importedNames, valueReferenced) {
+	for (const stmt of ast.body || []) {
+		const classNode = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration : stmt;
+		if (!classNode || classNode.type !== "ClassDeclaration" && classNode.type !== "ClassExpression") continue;
+		if (!classNode.decorators?.length) continue;
+		const ctor = (classNode.body?.body || []).find((m) => m.type === "MethodDefinition" && m.kind === "constructor");
+		if (!ctor) continue;
+		const params = ctor.value?.params?.items || ctor.value?.params || [];
+		for (const param of params) {
+			const typeAnn = (param.type === "TSParameterProperty" ? param.parameter : param)?.typeAnnotation?.typeAnnotation ?? param?.typeAnnotation?.typeAnnotation;
+			if (!typeAnn) continue;
+			collectTypeReferenceNames(typeAnn, importedNames, valueReferenced);
+		}
+	}
+}
+/**
+* Recursively extract identifier names from a TS type expression and mark
+* any that match an imported name as value-referenced.
+*/
+function collectTypeReferenceNames(typeNode, importedNames, valueReferenced) {
+	if (!typeNode || typeof typeNode !== "object") return;
+	if (typeNode.type === "TSTypeReference" && typeNode.typeName) {
+		const name = typeNode.typeName.name;
+		if (name && importedNames.has(name)) valueReferenced.add(name);
+		if (typeNode.typeArguments) collectTypeReferenceNames(typeNode.typeArguments, importedNames, valueReferenced);
+	} else if (typeNode.type === "TSUnionType" || typeNode.type === "TSIntersectionType") for (const t of typeNode.types || []) collectTypeReferenceNames(t, importedNames, valueReferenced);
+	else if (Array.isArray(typeNode)) for (const t of typeNode) collectTypeReferenceNames(t, importedNames, valueReferenced);
+	else if (typeNode.params) for (const t of typeNode.params) collectTypeReferenceNames(t, importedNames, valueReferenced);
+}
+/**
+* Analyse compiled TypeScript source and return the set of imported names
+* that are only referenced in type positions (type annotations, implements
+* clauses, generics, etc.) and can safely be elided.
+*
+* Uses oxc-parser for fast, Rust-based AST analysis — no type-checker needed.
+*/
+function detectTypeOnlyImportNames(code, program) {
+	return analyzeTypeOnlyImports(code, program).typeOnlyNames;
+}
+/**
+* Apply import elision edits to a MagicString instance using positions from
+* a parsed AST.  Shared logic for both the string-based and MagicString APIs.
+*/
+function applyElisionEdits(ms, ast, src, typeOnlyNames) {
+	let edited = false;
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.importKind === "type") continue;
+		const allSpecs = node.specifiers ?? [];
+		const defaultSpec = allSpecs.find((s) => s.type === "ImportDefaultSpecifier");
+		const namedSpecs = allSpecs.filter((s) => s.type === "ImportSpecifier" && s.importKind !== "type");
+		const elideDefault = defaultSpec && typeOnlyNames.has(defaultSpec.local.name);
+		const keptNamed = namedSpecs.filter((s) => !typeOnlyNames.has(s.local.name));
+		const removingNamed = namedSpecs.length - keptNamed.length;
+		if (!elideDefault && removingNamed === 0) continue;
+		let declEnd = node.end;
+		while (declEnd < src.length && (src[declEnd] === "\n" || src[declEnd] === "\r")) declEnd++;
+		const keepDefault = defaultSpec && !elideDefault;
+		const hasKeptNamed = keptNamed.length > 0;
+		if (!keepDefault && !hasKeptNamed) {
+			ms.remove(node.start, declEnd);
+			edited = true;
+		} else {
+			const parts = [];
+			if (keepDefault) parts.push(defaultSpec.local.name);
+			if (hasKeptNamed) {
+				const namedList = keptNamed.map((s) => {
+					const imported = s.imported?.name ?? s.local.name;
+					return imported === s.local.name ? s.local.name : `${imported} as ${s.local.name}`;
+				});
+				parts.push(`{ ${namedList.join(", ")} }`);
+			}
+			const source = node.source.value;
+			const quote = src[node.source.start];
+			ms.overwrite(node.start, node.end, `import ${parts.join(", ")} from ${quote}${source}${quote};`);
+			edited = true;
+		}
+	}
+	return edited;
+}
+/**
+* Elide type-only imports directly on a MagicString instance, so that
+* subsequent `ms.generateMap()` calls produce an accurate sourcemap.
+*
+* Detects type-only names from `ms.toString()` (the fully-mutated code),
+* but reads import positions from `ms.original` (the coordinate system
+* MagicString expects). `originalProgram`, when provided, must be a parse
+* of `ms.original` — never of the mutated text.
+*/
+function elideTypeOnlyImportsMagicString(ms, originalProgram) {
+	const typeOnlyNames = detectTypeOnlyImportNames(ms.toString());
+	if (typeOnlyNames.size === 0) return;
+	applyElisionEdits(ms, originalProgram ?? parseSync("file.ts", ms.original).program, ms.original, typeOnlyNames);
+}
+//#endregion
+export { detectTypeOnlyImportNames, elideTypeOnlyImportsMagicString };
+
+//# sourceMappingURL=type-elision.js.map