@analogjs/platform 3.0.0-alpha.3 → 3.0.0-alpha.31

package/src/lib/ssr/ssr-build-plugin.js

@@ -1,31 +1,55 @@
-import { normalizePath } from 'vite';
-export function ssrBuildPlugin() {
-    return {
-        name: 'analogjs-ssr-build-plugin',
-        transform(code, id) {
-            if (id.includes('zone-node') &&
-                code.includes('const global = globalThis;')) {
-                return {
-                    code: code.replace('const global = globalThis;', ''),
-                };
-            }
-            if (id.includes('platform-server')) {
-                return {
-                    code: code
-                        .replace('new xhr2.XMLHttpRequest', 'new (xhr2.default.XMLHttpRequest || xhr2.default)')
-                        .replaceAll('global.', 'globalThis.')
-                        .replaceAll('global,', 'globalThis,')
-                        .replaceAll(' global[', ' globalThis['),
-                };
-            }
-            // Remove usage of `with()` in sloppy.js file
-            if (id.includes(normalizePath('domino/lib/sloppy.js'))) {
-                return {
-                    code: code.replace(/with\(/gi, 'if('),
-                };
-            }
-            return;
-        },
-    };
+import * as vite from "vite";
+import { createRequire } from "node:module";
+//#region packages/platform/src/lib/ssr/ssr-build-plugin.ts
+/**
+* SSR build patches for Angular platform-server, Zone.js, and Domino.
+*
+* Returns an array of Vite plugins because under Vite 8+ (Rolldown) we
+* append Rolldown's built-in `replacePlugin` for an AST-safe
+* `global → globalThis` rewrite that avoids false positives inside string
+* literals and comments.
+*
+* **Why each patch exists:**
+* - zone-node: removes a `const global = globalThis` alias that shadows the
+*   real global in strict mode.
+* - platform-server: rewrites `xhr2.XMLHttpRequest` for CJS/ESM compat and
+*   replaces bare `global` references with `globalThis`.
+* - xhr2: strips Node-specific `os`/`process` references for SSR bundling.
+* - domino/sloppy.js: replaces `with()` statements that are illegal in ESM.
+*/
+function ssrBuildPlugin() {
+	const plugins = [{
+		name: "analogjs-ssr-build-plugin",
+		apply: "build",
+		config() {
+			return { ssr: { noExternal: ["xhr2"] } };
+		},
+		transform: {
+			filter: { id: /zone-node|platform-server|xhr2\.js|domino\/lib\/sloppy\.js/ },
+			handler(code, id) {
+				if (id.includes("zone-node") && code.includes("const global = globalThis;")) return { code: code.replace("const global = globalThis;", "") };
+				if (id.includes("platform-server")) {
+					let result = code.replace("new xhr2.XMLHttpRequest", "new (xhr2.default.XMLHttpRequest || xhr2.default)");
+					if (!vite.rolldownVersion) result = result.replaceAll("global.", "globalThis.").replaceAll("global,", "globalThis,").replaceAll(" global[", " globalThis[");
+					return { code: result };
+				}
+				if (id.includes(vite.normalizePath("xhr2.js"))) return { code: code.replace("os.type()", `''`).replace("os.arch()", `''`).replace("process.versions.node", `'node'`).replace("process.versions.v8", `'v8'`) };
+				if (id.includes(vite.normalizePath("domino/lib/sloppy.js"))) return { code: code.replace(/with\(/gi, "if(") };
+			}
+		}
+	}];
+	if (vite.rolldownVersion) {
+		const require = createRequire(import.meta.url);
+		const { replacePlugin } = require("rolldown/plugins");
+		const { withFilter } = require("rolldown/filter");
+		plugins.push(withFilter(replacePlugin({ global: "globalThis" }, {
+			preventAssignment: true,
+			objectGuards: true
+		}), { transform: { id: /platform-server/ } }));
+	}
+	return plugins;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NyLWJ1aWxkLXBsdWdpbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3BsYXRmb3JtL3NyYy9saWIvc3NyL3Nzci1idWlsZC1wbHVnaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBVSxNQUFNLE1BQU0sQ0FBQztBQUU3QyxNQUFNLFVBQVUsY0FBYztJQUM1QixPQUFPO1FBQ0wsSUFBSSxFQUFFLDJCQUEyQjtRQUNqQyxTQUFTLENBQUMsSUFBSSxFQUFFLEVBQUU7WUFDaEIsSUFDRSxFQUFFLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQztnQkFDeEIsSUFBSSxDQUFDLFFBQVEsQ0FBQyw0QkFBNEIsQ0FBQyxFQUMzQyxDQUFDO2dCQUNELE9BQU87b0JBQ0wsSUFBSSxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsNEJBQTRCLEVBQUUsRUFBRSxDQUFDO2lCQUNyRCxDQUFDO1lBQ0osQ0FBQztZQUVELElBQUksRUFBRSxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLENBQUM7Z0JBQ25DLE9BQU87b0JBQ0wsSUFBSSxFQUFFLElBQUk7eUJBQ1AsT0FBTyxDQUNOLHlCQUF5QixFQUN6QixtREFBbUQsQ0FDcEQ7eUJBQ0EsVUFBVSxDQUFDLFNBQVMsRUFBRSxhQUFhLENBQUM7eUJBQ3BDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsYUFBYSxDQUFDO3lCQUNwQyxVQUFVLENBQUMsVUFBVSxFQUFFLGNBQWMsQ0FBQztpQkFDMUMsQ0FBQztZQUNKLENBQUM7WUFFRCw2Q0FBNkM7WUFDN0MsSUFBSSxFQUFFLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDLEVBQUUsQ0FBQztnQkFDdkQsT0FBTztvQkFDTCxJQUFJLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsS0FBSyxDQUFDO2lCQUN0QyxDQUFDO1lBQ0osQ0FBQztZQUVELE9BQU87UUFDVCxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUMifQ==
+//#endregion
+export { ssrBuildPlugin };
+
+//# sourceMappingURL=ssr-build-plugin.js.map

package/src/lib/ssr/ssr-build-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-build-plugin.js","names":[],"sources":["../../../../src/lib/ssr/ssr-build-plugin.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport * as vite from 'vite';\n\n/**\n * SSR build patches for Angular platform-server, Zone.js, and Domino.\n *\n * Returns an array of Vite plugins because under Vite 8+ (Rolldown) we\n * append Rolldown's built-in `replacePlugin` for an AST-safe\n * `global → globalThis` rewrite that avoids false positives inside string\n * literals and comments.\n *\n * **Why each patch exists:**\n * - zone-node: removes a `const global = globalThis` alias that shadows the\n *   real global in strict mode.\n * - platform-server: rewrites `xhr2.XMLHttpRequest` for CJS/ESM compat and\n *   replaces bare `global` references with `globalThis`.\n * - xhr2: strips Node-specific `os`/`process` references for SSR bundling.\n * - domino/sloppy.js: replaces `with()` statements that are illegal in ESM.\n */\nexport function ssrBuildPlugin(): vite.Plugin[] {\n  const plugins: vite.Plugin[] = [\n    {\n      name: 'analogjs-ssr-build-plugin',\n      apply: 'build',\n      config() {\n        return {\n          ssr: {\n            noExternal: ['xhr2'],\n          },\n        };\n      },\n      transform: {\n        filter: {\n          id: /zone-node|platform-server|xhr2\\.js|domino\\/lib\\/sloppy\\.js/,\n        },\n        handler(code, id) {\n          if (\n            id.includes('zone-node') &&\n            code.includes('const global = globalThis;')\n          ) {\n            return {\n              code: code.replace('const global = globalThis;', ''),\n            };\n          }\n\n          if (id.includes('platform-server')) {\n            let result = code.replace(\n              'new xhr2.XMLHttpRequest',\n              'new (xhr2.default.XMLHttpRequest || xhr2.default)',\n            );\n\n            // Under Vite 8+ the appended `replacePlugin` handles\n            // global → globalThis via AST-aware replacement (scoped to\n            // platform-server by `withFilter`).  For Vite ≤7 we fall back\n            // to text-based replaceAll — imprecise but sufficient for the\n            // known occurrences in @angular/platform-server bundles.\n            if (!vite.rolldownVersion) {\n              result = result\n                .replaceAll('global.', 'globalThis.')\n                .replaceAll('global,', 'globalThis,')\n                .replaceAll(' global[', ' globalThis[');\n            }\n\n            return { code: result };\n          }\n\n          if (id.includes(vite.normalizePath('xhr2.js'))) {\n            return {\n              code: code\n                .replace('os.type()', `''`)\n                .replace('os.arch()', `''`)\n                .replace('process.versions.node', `'node'`)\n                .replace('process.versions.v8', `'v8'`),\n            };\n          }\n\n          if (id.includes(vite.normalizePath('domino/lib/sloppy.js'))) {\n            return {\n              code: code.replace(/with\\(/gi, 'if('),\n            };\n          }\n\n          return;\n        },\n      },\n    },\n  ];\n\n  // Under Vite 8+ (Rolldown), append Rolldown's built-in `replacePlugin`\n  // for AST-aware `global → globalThis` rewriting scoped to platform-server.\n  //\n  // `createRequire` is used instead of dynamic `import()` because this code\n  // runs synchronously during plugin construction (not inside an async hook).\n  // Rolldown is guaranteed to be installed when `vite.rolldownVersion` is truthy.\n  if (vite.rolldownVersion) {\n    const require = createRequire(import.meta.url);\n    const { replacePlugin } =\n      require('rolldown/plugins') as typeof import('rolldown/plugins');\n    const { withFilter } =\n      require('rolldown/filter') as typeof import('rolldown/filter');\n\n    plugins.push(\n      withFilter(\n        replacePlugin(\n          { global: 'globalThis' },\n          { preventAssignment: true, objectGuards: true },\n        ),\n        { transform: { id: /platform-server/ } },\n      ) as unknown as vite.Plugin,\n    );\n  }\n\n  return plugins;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAgC;CAC9C,MAAM,UAAyB,CAC7B;EACE,MAAM;EACN,OAAO;EACP,SAAS;AACP,UAAO,EACL,KAAK,EACH,YAAY,CAAC,OAAO,EACrB,EACF;;EAEH,WAAW;GACT,QAAQ,EACN,IAAI,8DACL;GACD,QAAQ,MAAM,IAAI;AAChB,QACE,GAAG,SAAS,YAAY,IACxB,KAAK,SAAS,6BAA6B,CAE3C,QAAO,EACL,MAAM,KAAK,QAAQ,8BAA8B,GAAG,EACrD;AAGH,QAAI,GAAG,SAAS,kBAAkB,EAAE;KAClC,IAAI,SAAS,KAAK,QAChB,2BACA,oDACD;AAOD,SAAI,CAAC,KAAK,gBACR,UAAS,OACN,WAAW,WAAW,cAAc,CACpC,WAAW,WAAW,cAAc,CACpC,WAAW,YAAY,eAAe;AAG3C,YAAO,EAAE,MAAM,QAAQ;;AAGzB,QAAI,GAAG,SAAS,KAAK,cAAc,UAAU,CAAC,CAC5C,QAAO,EACL,MAAM,KACH,QAAQ,aAAa,KAAK,CAC1B,QAAQ,aAAa,KAAK,CAC1B,QAAQ,yBAAyB,SAAS,CAC1C,QAAQ,uBAAuB,OAAO,EAC1C;AAGH,QAAI,GAAG,SAAS,KAAK,cAAc,uBAAuB,CAAC,CACzD,QAAO,EACL,MAAM,KAAK,QAAQ,YAAY,MAAM,EACtC;;GAKN;EACF,CACF;AAQD,KAAI,KAAK,iBAAiB;EACxB,MAAM,UAAU,cAAc,OAAO,KAAK,IAAI;EAC9C,MAAM,EAAE,kBACN,QAAQ,mBAAmB;EAC7B,MAAM,EAAE,eACN,QAAQ,kBAAkB;AAE5B,UAAQ,KACN,WACE,cACE,EAAE,QAAQ,cAAc,EACxB;GAAE,mBAAmB;GAAM,cAAc;GAAM,CAChD,EACD,EAAE,WAAW,EAAE,IAAI,mBAAmB,EAAE,CACzC,CACF;;AAGH,QAAO"}

package/src/lib/style-pipeline.d.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from "vite";
+import type { StylesheetDependency, StylesheetDiagnostic, StylesheetTransformContext, StylesheetTransformResult } from "./style-preprocessor.js";
+export interface StylePipelineStylesheetRegistry {
+	getPublicIdsForSource(sourcePath: string): string[];
+	getRequestIdsForSource(sourcePath: string): string[];
+	getDependenciesForSource(sourcePath: string): StylesheetDependency[];
+	getDiagnosticsForSource(sourcePath: string): StylesheetDiagnostic[];
+	getTagsForSource(sourcePath: string): string[];
+}
+export interface AngularStylePipelineContext {
+	workspaceRoot: string;
+}
+export interface AngularStylePipelinePlugin {
+	name: string;
+	preprocessStylesheet?: (code: string, context: StylesheetTransformContext) => string | StylesheetTransformResult | undefined;
+	configureStylesheetRegistry?: (registry: StylePipelineStylesheetRegistry, context: AngularStylePipelineContext) => void;
+}
+export interface AngularStylePipelineOptions {
+	plugins: AngularStylePipelinePlugin[];
+}
+export declare function defineAngularStylePipeline<const T extends AngularStylePipelineOptions>(options: T): T;
+export declare function defineAngularStylePipelinePlugins<const T extends AngularStylePipelinePlugin[]>(plugins: T): T;
+export interface StylePipelineContext {
+	workspaceRoot: string;
+}
+export type StylePipelinePluginFactory = (context: StylePipelineContext) => Plugin | Plugin[] | false | null | undefined;
+export type StylePipelinePluginEntry = Plugin | Plugin[] | StylePipelinePluginFactory | false | null | undefined;
+export interface StylePipelineOptions {
+	plugins?: StylePipelinePluginEntry[];
+	angularPlugins?: AngularStylePipelinePlugin[];
+}
+export declare function defineStylePipeline<const T extends StylePipelineOptions>(options: T): T;
+export declare function defineStylePipelinePlugins<const T extends StylePipelinePluginEntry[]>(plugins: T): T;
+export declare function resolveStylePipelinePlugins(options: StylePipelineOptions | false | undefined, workspaceRoot?: string): Plugin[];

package/src/lib/style-pipeline.js

@@ -0,0 +1,32 @@
+//#region packages/platform/src/lib/style-pipeline.ts
+function defineAngularStylePipeline(options) {
+	return options;
+}
+function defineAngularStylePipelinePlugins(plugins) {
+	return plugins;
+}
+function defineStylePipeline(options) {
+	return options;
+}
+function defineStylePipelinePlugins(plugins) {
+	return plugins;
+}
+function resolveStylePipelinePlugins(options, workspaceRoot) {
+	if (!options?.plugins?.length) return [];
+	const context = { workspaceRoot: workspaceRoot ?? process.env["NX_WORKSPACE_ROOT"] ?? process.cwd() };
+	const resolved = [];
+	for (const entry of options.plugins) {
+		const plugins = typeof entry === "function" ? entry(context) : entry;
+		if (!plugins) continue;
+		if (Array.isArray(plugins)) {
+			resolved.push(...plugins);
+			continue;
+		}
+		resolved.push(plugins);
+	}
+	return resolved;
+}
+//#endregion
+export { defineAngularStylePipeline, defineAngularStylePipelinePlugins, defineStylePipeline, defineStylePipelinePlugins, resolveStylePipelinePlugins };
+
+//# sourceMappingURL=style-pipeline.js.map

package/src/lib/style-pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-pipeline.js","names":[],"sources":["../../../src/lib/style-pipeline.ts"],"sourcesContent":["import type { Plugin } from 'vite';\nimport type {\n  StylesheetDependency,\n  StylesheetDiagnostic,\n  StylesheetTransformContext,\n  StylesheetTransformResult,\n} from './style-preprocessor.js';\n\nexport interface StylePipelineStylesheetRegistry {\n  getPublicIdsForSource(sourcePath: string): string[];\n  getRequestIdsForSource(sourcePath: string): string[];\n  getDependenciesForSource(sourcePath: string): StylesheetDependency[];\n  getDiagnosticsForSource(sourcePath: string): StylesheetDiagnostic[];\n  getTagsForSource(sourcePath: string): string[];\n}\n\nexport interface AngularStylePipelineContext {\n  workspaceRoot: string;\n}\n\nexport interface AngularStylePipelinePlugin {\n  name: string;\n  preprocessStylesheet?: (\n    code: string,\n    context: StylesheetTransformContext,\n  ) => string | StylesheetTransformResult | undefined;\n  configureStylesheetRegistry?: (\n    registry: StylePipelineStylesheetRegistry,\n    context: AngularStylePipelineContext,\n  ) => void;\n}\n\nexport interface AngularStylePipelineOptions {\n  plugins: AngularStylePipelinePlugin[];\n}\n\nexport function defineAngularStylePipeline<\n  const T extends AngularStylePipelineOptions,\n>(options: T): T {\n  return options;\n}\n\nexport function defineAngularStylePipelinePlugins<\n  const T extends AngularStylePipelinePlugin[],\n>(plugins: T): T {\n  return plugins;\n}\n\nexport interface StylePipelineContext {\n  workspaceRoot: string;\n}\n\nexport type StylePipelinePluginFactory = (\n  context: StylePipelineContext,\n) => Plugin | Plugin[] | false | null | undefined;\n\nexport type StylePipelinePluginEntry =\n  | Plugin\n  | Plugin[]\n  | StylePipelinePluginFactory\n  | false\n  | null\n  | undefined;\n\nexport interface StylePipelineOptions {\n  plugins?: StylePipelinePluginEntry[];\n  angularPlugins?: AngularStylePipelinePlugin[];\n}\n\nexport function defineStylePipeline<const T extends StylePipelineOptions>(\n  options: T,\n): T {\n  return options;\n}\n\nexport function defineStylePipelinePlugins<\n  const T extends StylePipelinePluginEntry[],\n>(plugins: T): T {\n  return plugins;\n}\n\nexport function resolveStylePipelinePlugins(\n  options: StylePipelineOptions | false | undefined,\n  workspaceRoot?: string,\n): Plugin[] {\n  if (!options?.plugins?.length) {\n    return [];\n  }\n\n  const context: StylePipelineContext = {\n    workspaceRoot:\n      workspaceRoot ?? process.env['NX_WORKSPACE_ROOT'] ?? process.cwd(),\n  };\n\n  const resolved: Plugin[] = [];\n\n  for (const entry of options.plugins) {\n    const plugins = typeof entry === 'function' ? entry(context) : entry;\n\n    if (!plugins) {\n      continue;\n    }\n\n    if (Array.isArray(plugins)) {\n      resolved.push(...plugins);\n      continue;\n    }\n\n    resolved.push(plugins);\n  }\n\n  return resolved;\n}\n"],"mappings":";AAoCA,SAAgB,2BAEd,SAAe;AACf,QAAO;;AAGT,SAAgB,kCAEd,SAAe;AACf,QAAO;;AAwBT,SAAgB,oBACd,SACG;AACH,QAAO;;AAGT,SAAgB,2BAEd,SAAe;AACf,QAAO;;AAGT,SAAgB,4BACd,SACA,eACU;AACV,KAAI,CAAC,SAAS,SAAS,OACrB,QAAO,EAAE;CAGX,MAAM,UAAgC,EACpC,eACE,iBAAiB,QAAQ,IAAI,wBAAwB,QAAQ,KAAK,EACrE;CAED,MAAM,WAAqB,EAAE;AAE7B,MAAK,MAAM,SAAS,QAAQ,SAAS;EACnC,MAAM,UAAU,OAAO,UAAU,aAAa,MAAM,QAAQ,GAAG;AAE/D,MAAI,CAAC,QACH;AAGF,MAAI,MAAM,QAAQ,QAAQ,EAAE;AAC1B,YAAS,KAAK,GAAG,QAAQ;AACzB;;AAGF,WAAS,KAAK,QAAQ;;AAGxB,QAAO"}

package/src/lib/style-preprocessor.d.ts

@@ -0,0 +1,28 @@
+export interface StylesheetTransformContext {
+	filename: string;
+	containingFile?: string;
+	resourceFile?: string;
+	className?: string;
+	order?: number;
+	inline: boolean;
+}
+export interface StylesheetDependency {
+	id: string;
+	kind?: "file" | "virtual" | "token" | "bridge" | "manifest" | "runtime";
+	owner?: string;
+}
+export interface StylesheetDiagnostic {
+	severity: "warning" | "error";
+	code: string;
+	message: string;
+}
+export interface StylesheetTransformResult {
+	code: string;
+	dependencies?: Array<string | StylesheetDependency>;
+	diagnostics?: StylesheetDiagnostic[];
+	tags?: string[];
+}
+export type StylePreprocessor = (code: string, filename: string, context?: StylesheetTransformContext) => string | StylesheetTransformResult;
+export declare function normalizeStylesheetTransformResult(value: string | StylesheetTransformResult | undefined, fallbackCode: string): StylesheetTransformResult;
+export declare function normalizeStylesheetDependencies(dependencies: Array<string | StylesheetDependency> | undefined): StylesheetDependency[];
+export declare function composeStylePreprocessors(preprocessors: Array<StylePreprocessor | false | null | undefined>): StylePreprocessor | undefined;

package/src/lib/style-preprocessor.js

@@ -0,0 +1,35 @@
+//#region packages/platform/src/lib/style-preprocessor.ts
+function normalizeStylesheetTransformResult(value, fallbackCode) {
+	if (value == null) return { code: fallbackCode };
+	if (typeof value === "string") return { code: value };
+	return {
+		code: value.code ?? fallbackCode,
+		dependencies: normalizeStylesheetDependencies(value.dependencies),
+		diagnostics: value.diagnostics ?? [],
+		tags: value.tags ?? []
+	};
+}
+function normalizeStylesheetDependencies(dependencies) {
+	return (dependencies ?? []).map((dependency) => typeof dependency === "string" ? { id: dependency } : dependency);
+}
+function composeStylePreprocessors(preprocessors) {
+	const active = preprocessors.filter((preprocessor) => !!preprocessor);
+	if (!active.length) return;
+	return (code, filename, context) => {
+		let current = normalizeStylesheetTransformResult(void 0, code);
+		for (const preprocessor of active) {
+			const next = normalizeStylesheetTransformResult(preprocessor(current.code, filename, context), current.code);
+			current = {
+				code: next.code,
+				dependencies: [...current.dependencies ?? [], ...next.dependencies ?? []],
+				diagnostics: [...current.diagnostics ?? [], ...next.diagnostics ?? []],
+				tags: [...current.tags ?? [], ...next.tags ?? []]
+			};
+		}
+		return current;
+	};
+}
+//#endregion
+export { composeStylePreprocessors, normalizeStylesheetDependencies, normalizeStylesheetTransformResult };
+
+//# sourceMappingURL=style-preprocessor.js.map

package/src/lib/style-preprocessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-preprocessor.js","names":[],"sources":["../../../src/lib/style-preprocessor.ts"],"sourcesContent":["export interface StylesheetTransformContext {\n  filename: string;\n  containingFile?: string;\n  resourceFile?: string;\n  className?: string;\n  order?: number;\n  inline: boolean;\n}\n\nexport interface StylesheetDependency {\n  id: string;\n  kind?: 'file' | 'virtual' | 'token' | 'bridge' | 'manifest' | 'runtime';\n  owner?: string;\n}\n\nexport interface StylesheetDiagnostic {\n  severity: 'warning' | 'error';\n  code: string;\n  message: string;\n}\n\nexport interface StylesheetTransformResult {\n  code: string;\n  dependencies?: Array<string | StylesheetDependency>;\n  diagnostics?: StylesheetDiagnostic[];\n  tags?: string[];\n}\n\nexport type StylePreprocessor = (\n  code: string,\n  filename: string,\n  context?: StylesheetTransformContext,\n) => string | StylesheetTransformResult;\n\nexport function normalizeStylesheetTransformResult(\n  value: string | StylesheetTransformResult | undefined,\n  fallbackCode: string,\n): StylesheetTransformResult {\n  if (value == null) {\n    return { code: fallbackCode };\n  }\n\n  if (typeof value === 'string') {\n    return { code: value };\n  }\n\n  return {\n    code: value.code ?? fallbackCode,\n    dependencies: normalizeStylesheetDependencies(value.dependencies),\n    diagnostics: value.diagnostics ?? [],\n    tags: value.tags ?? [],\n  };\n}\n\nexport function normalizeStylesheetDependencies(\n  dependencies: Array<string | StylesheetDependency> | undefined,\n): StylesheetDependency[] {\n  return (dependencies ?? []).map((dependency) =>\n    typeof dependency === 'string' ? { id: dependency } : dependency,\n  );\n}\n\nexport function composeStylePreprocessors(\n  preprocessors: Array<StylePreprocessor | false | null | undefined>,\n): StylePreprocessor | undefined {\n  const active = preprocessors.filter(\n    (preprocessor): preprocessor is StylePreprocessor => !!preprocessor,\n  );\n\n  if (!active.length) {\n    return undefined;\n  }\n\n  return (code, filename, context) => {\n    let current = normalizeStylesheetTransformResult(undefined, code);\n\n    for (const preprocessor of active) {\n      const next = normalizeStylesheetTransformResult(\n        preprocessor(current.code, filename, context),\n        current.code,\n      );\n      current = {\n        code: next.code,\n        dependencies: [\n          ...(current.dependencies ?? []),\n          ...(next.dependencies ?? []),\n        ],\n        diagnostics: [\n          ...(current.diagnostics ?? []),\n          ...(next.diagnostics ?? []),\n        ],\n        tags: [...(current.tags ?? []), ...(next.tags ?? [])],\n      };\n    }\n\n    return current;\n  };\n}\n"],"mappings":";AAkCA,SAAgB,mCACd,OACA,cAC2B;AAC3B,KAAI,SAAS,KACX,QAAO,EAAE,MAAM,cAAc;AAG/B,KAAI,OAAO,UAAU,SACnB,QAAO,EAAE,MAAM,OAAO;AAGxB,QAAO;EACL,MAAM,MAAM,QAAQ;EACpB,cAAc,gCAAgC,MAAM,aAAa;EACjE,aAAa,MAAM,eAAe,EAAE;EACpC,MAAM,MAAM,QAAQ,EAAE;EACvB;;AAGH,SAAgB,gCACd,cACwB;AACxB,SAAQ,gBAAgB,EAAE,EAAE,KAAK,eAC/B,OAAO,eAAe,WAAW,EAAE,IAAI,YAAY,GAAG,WACvD;;AAGH,SAAgB,0BACd,eAC+B;CAC/B,MAAM,SAAS,cAAc,QAC1B,iBAAoD,CAAC,CAAC,aACxD;AAED,KAAI,CAAC,OAAO,OACV;AAGF,SAAQ,MAAM,UAAU,YAAY;EAClC,IAAI,UAAU,mCAAmC,KAAA,GAAW,KAAK;AAEjE,OAAK,MAAM,gBAAgB,QAAQ;GACjC,MAAM,OAAO,mCACX,aAAa,QAAQ,MAAM,UAAU,QAAQ,EAC7C,QAAQ,KACT;AACD,aAAU;IACR,MAAM,KAAK;IACX,cAAc,CACZ,GAAI,QAAQ,gBAAgB,EAAE,EAC9B,GAAI,KAAK,gBAAgB,EAAE,CAC5B;IACD,aAAa,CACX,GAAI,QAAQ,eAAe,EAAE,EAC7B,GAAI,KAAK,eAAe,EAAE,CAC3B;IACD,MAAM,CAAC,GAAI,QAAQ,QAAQ,EAAE,EAAG,GAAI,KAAK,QAAQ,EAAE,CAAE;IACtD;;AAGH,SAAO"}

package/src/lib/tailwind-preprocessor.d.ts

@@ -0,0 +1,23 @@
+import type { StylePreprocessor } from "./style-preprocessor.js";
+export type TailwindPreprocessorMode = "auto" | "disabled" | {
+	prefix: string;
+};
+export interface TailwindPreprocessorOptions {
+	/** Absolute path to the Tailwind root CSS file that imports `tailwindcss`. */
+	tailwindRootCss: string;
+	/**
+	* Controls whether the preprocessor auto-detects, disables, or manually
+	* overrides the Tailwind prefix for a given file.
+	*/
+	mode?: TailwindPreprocessorMode | ((filename: string) => TailwindPreprocessorMode);
+	/**
+	* Optional predicate to override the default `@reference` injection behavior.
+	*/
+	shouldInject?: (code: string, filename: string, resolvedPrefix: string | null) => boolean;
+}
+/**
+* Creates a stylesheet preprocessor that injects Tailwind v4 `@reference`
+* directives into Angular component styles when needed. The Tailwind prefix is
+* detected from the configured root CSS file.
+*/
+export declare function tailwindPreprocessor(options: TailwindPreprocessorOptions): StylePreprocessor;

package/src/lib/tailwind-preprocessor.js

@@ -0,0 +1,57 @@
+import { debugTailwind } from "./utils/debug.js";
+import path from "node:path";
+import { readFileSync } from "node:fs";
+//#region packages/platform/src/lib/tailwind-preprocessor.ts
+/**
+* Creates a stylesheet preprocessor that injects Tailwind v4 `@reference`
+* directives into Angular component styles when needed. The Tailwind prefix is
+* detected from the configured root CSS file.
+*/
+function tailwindPreprocessor(options) {
+	const { tailwindRootCss, mode: modeOption = "auto", shouldInject } = options;
+	let rootPrefix;
+	debugTailwind("configured", {
+		tailwindRootCss,
+		mode: modeOption
+	});
+	return (code, filename) => {
+		if (code.includes("@reference")) {
+			debugTailwind("skip (already has @reference)", { filename });
+			return code;
+		}
+		const resolvedMode = typeof modeOption === "function" ? modeOption(filename) : modeOption;
+		if (resolvedMode === "disabled") {
+			debugTailwind("skip (mode disabled)", { filename });
+			return code;
+		}
+		const resolvedPrefix = typeof resolvedMode === "object" ? resolvedMode.prefix : getRootPrefix();
+		const isRootFile = path.resolve(filename) === path.resolve(tailwindRootCss) || /@import\s+["']tailwindcss["']/.test(code);
+		const hasTailwindUsage = resolvedPrefix ? code.includes(`${resolvedPrefix}:`) : false;
+		if (!(shouldInject ? shouldInject(code, filename, resolvedPrefix) : hasTailwindUsage && !isRootFile) || !resolvedPrefix) {
+			debugTailwind("skip (no injection needed)", {
+				filename,
+				resolvedPrefix,
+				isRootFile,
+				hasTailwindUsage
+			});
+			return code;
+		}
+		const refPath = path.relative(path.dirname(filename), tailwindRootCss).replace(/\\/g, "/");
+		debugTailwind("injected @reference", {
+			filename,
+			refPath
+		});
+		return `@reference "${refPath}";\n${code}`;
+	};
+	function getRootPrefix() {
+		if (rootPrefix === void 0) rootPrefix = extractTailwindPrefix(readFileSync(tailwindRootCss, "utf-8"));
+		return rootPrefix;
+	}
+}
+function extractTailwindPrefix(code) {
+	return code.match(/@import\s+["']tailwindcss["']\s+prefix\(\s*([^)\s;]+)\s*\)/i)?.[1]?.trim() ?? null;
+}
+//#endregion
+export { tailwindPreprocessor };
+
+//# sourceMappingURL=tailwind-preprocessor.js.map

package/src/lib/tailwind-preprocessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwind-preprocessor.js","names":[],"sources":["../../../src/lib/tailwind-preprocessor.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport path from 'node:path';\n\nimport type { StylePreprocessor } from './style-preprocessor.js';\nimport { debugTailwind } from './utils/debug.js';\n\nexport type TailwindPreprocessorMode = 'auto' | 'disabled' | { prefix: string };\n\nexport interface TailwindPreprocessorOptions {\n  /** Absolute path to the Tailwind root CSS file that imports `tailwindcss`. */\n  tailwindRootCss: string;\n\n  /**\n   * Controls whether the preprocessor auto-detects, disables, or manually\n   * overrides the Tailwind prefix for a given file.\n   */\n  mode?:\n    | TailwindPreprocessorMode\n    | ((filename: string) => TailwindPreprocessorMode);\n\n  /**\n   * Optional predicate to override the default `@reference` injection behavior.\n   */\n  shouldInject?: (\n    code: string,\n    filename: string,\n    resolvedPrefix: string | null,\n  ) => boolean;\n}\n\n/**\n * Creates a stylesheet preprocessor that injects Tailwind v4 `@reference`\n * directives into Angular component styles when needed. The Tailwind prefix is\n * detected from the configured root CSS file.\n */\nexport function tailwindPreprocessor(\n  options: TailwindPreprocessorOptions,\n): StylePreprocessor {\n  const { tailwindRootCss, mode: modeOption = 'auto', shouldInject } = options;\n  let rootPrefix: string | undefined;\n\n  debugTailwind('configured', { tailwindRootCss, mode: modeOption });\n\n  return (code: string, filename: string): string => {\n    if (code.includes('@reference')) {\n      debugTailwind('skip (already has @reference)', { filename });\n      return code;\n    }\n\n    const resolvedMode =\n      typeof modeOption === 'function' ? modeOption(filename) : modeOption;\n\n    if (resolvedMode === 'disabled') {\n      debugTailwind('skip (mode disabled)', { filename });\n      return code;\n    }\n\n    const resolvedPrefix =\n      typeof resolvedMode === 'object' ? resolvedMode.prefix : getRootPrefix();\n    const isRootFile =\n      path.resolve(filename) === path.resolve(tailwindRootCss) ||\n      /@import\\s+[\"']tailwindcss[\"']/.test(code);\n    const hasTailwindUsage = resolvedPrefix\n      ? code.includes(`${resolvedPrefix}:`)\n      : false;\n    const shouldAddReference = shouldInject\n      ? shouldInject(code, filename, resolvedPrefix)\n      : hasTailwindUsage && !isRootFile;\n\n    if (!shouldAddReference || !resolvedPrefix) {\n      debugTailwind('skip (no injection needed)', {\n        filename,\n        resolvedPrefix,\n        isRootFile,\n        hasTailwindUsage,\n      });\n      return code;\n    }\n\n    const refPath = path\n      .relative(path.dirname(filename), tailwindRootCss)\n      .replace(/\\\\/g, '/');\n    debugTailwind('injected @reference', { filename, refPath });\n\n    return `@reference \"${refPath}\";\\n${code}`;\n  };\n\n  function getRootPrefix(): string | null {\n    if (rootPrefix === undefined) {\n      rootPrefix = extractTailwindPrefix(\n        readFileSync(tailwindRootCss, 'utf-8'),\n      );\n    }\n\n    return rootPrefix;\n  }\n}\n\nfunction extractTailwindPrefix(code: string): string | null {\n  const prefixMatch = code.match(\n    /@import\\s+[\"']tailwindcss[\"']\\s+prefix\\(\\s*([^)\\s;]+)\\s*\\)/i,\n  );\n\n  return prefixMatch?.[1]?.trim() ?? null;\n}\n"],"mappings":";;;;;;;;;AAmCA,SAAgB,qBACd,SACmB;CACnB,MAAM,EAAE,iBAAiB,MAAM,aAAa,QAAQ,iBAAiB;CACrE,IAAI;AAEJ,eAAc,cAAc;EAAE;EAAiB,MAAM;EAAY,CAAC;AAElE,SAAQ,MAAc,aAA6B;AACjD,MAAI,KAAK,SAAS,aAAa,EAAE;AAC/B,iBAAc,iCAAiC,EAAE,UAAU,CAAC;AAC5D,UAAO;;EAGT,MAAM,eACJ,OAAO,eAAe,aAAa,WAAW,SAAS,GAAG;AAE5D,MAAI,iBAAiB,YAAY;AAC/B,iBAAc,wBAAwB,EAAE,UAAU,CAAC;AACnD,UAAO;;EAGT,MAAM,iBACJ,OAAO,iBAAiB,WAAW,aAAa,SAAS,eAAe;EAC1E,MAAM,aACJ,KAAK,QAAQ,SAAS,KAAK,KAAK,QAAQ,gBAAgB,IACxD,gCAAgC,KAAK,KAAK;EAC5C,MAAM,mBAAmB,iBACrB,KAAK,SAAS,GAAG,eAAe,GAAG,GACnC;AAKJ,MAAI,EAJuB,eACvB,aAAa,MAAM,UAAU,eAAe,GAC5C,oBAAoB,CAAC,eAEE,CAAC,gBAAgB;AAC1C,iBAAc,8BAA8B;IAC1C;IACA;IACA;IACA;IACD,CAAC;AACF,UAAO;;EAGT,MAAM,UAAU,KACb,SAAS,KAAK,QAAQ,SAAS,EAAE,gBAAgB,CACjD,QAAQ,OAAO,IAAI;AACtB,gBAAc,uBAAuB;GAAE;GAAU;GAAS,CAAC;AAE3D,SAAO,eAAe,QAAQ,MAAM;;CAGtC,SAAS,gBAA+B;AACtC,MAAI,eAAe,KAAA,EACjB,cAAa,sBACX,aAAa,iBAAiB,QAAQ,CACvC;AAGH,SAAO;;;AAIX,SAAS,sBAAsB,MAA6B;AAK1D,QAJoB,KAAK,MACvB,8DACD,GAEoB,IAAI,MAAM,IAAI"}

package/src/lib/typed-routes-plugin.d.ts

@@ -0,0 +1,50 @@
+import { type Plugin } from "vite";
+export interface TypedRoutesPluginOptions {
+	/**
+	* Output path for the single generated route module,
+	* relative to the app root.
+	*
+	* @default 'src/routeTree.gen.ts'
+	*/
+	outFile?: string;
+	/**
+	* Workspace root used to resolve additional route/content directories.
+	*
+	* @default process.env['NX_WORKSPACE_ROOT'] ?? process.cwd()
+	*/
+	workspaceRoot?: string;
+	/**
+	* Additional page directories to scan for `.page.ts` files.
+	*/
+	additionalPagesDirs?: string[];
+	/**
+	* Additional content directories to scan for `.md` files.
+	*/
+	additionalContentDirs?: string[];
+	/**
+	* Include generated `routeJsonLdManifest` exports in the generated route file.
+	*
+	* @default true
+	*/
+	jsonLdManifest?: boolean;
+	/**
+	* When true, compare generated output against the existing file and
+	* throw an error if they differ instead of writing. Useful for CI to
+	* detect stale checked-in route files.
+	*
+	* @default false
+	*/
+	verify?: boolean;
+	/**
+	* When true, production builds fail after regenerating a stale checked-in
+	* route file. This preserves self-healing writes in development while making
+	* build-time freshness issues visible by default.
+	*
+	* @default true
+	*/
+	verifyOnBuild?: boolean;
+}
+/**
+* Vite plugin that generates a single typed route module for Analog file routes.
+*/
+export declare function typedRoutes(options?: TypedRoutesPluginOptions): Plugin;

package/src/lib/typed-routes-plugin.js

@@ -0,0 +1,234 @@
+import { debugTypedRouter } from "./utils/debug.js";
+import { detectSchemaExports, filenameToRoutePath, formatManifestSummary, generateRouteManifest, generateRouteTableDeclaration, generateRouteTreeDeclaration } from "./route-manifest.js";
+import { detectJsonLdModuleExports, extractMarkdownJsonLd, generateJsonLdManifestSource } from "./json-ld-manifest-plugin.js";
+import { createRouteFileDiscovery } from "./route-file-discovery.js";
+import { dirname, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { normalizePath } from "vite";
+//#region packages/platform/src/lib/typed-routes-plugin.ts
+var DEFAULT_OUT_FILE = "src/routeTree.gen.ts";
+function resolvePluginOptions(options = {}) {
+	return {
+		outFile: options.outFile ?? DEFAULT_OUT_FILE,
+		workspaceRoot: options.workspaceRoot ?? process.env["NX_WORKSPACE_ROOT"] ?? process.cwd(),
+		additionalPagesDirs: options.additionalPagesDirs ?? [],
+		additionalContentDirs: options.additionalContentDirs ?? [],
+		jsonLdManifest: options.jsonLdManifest ?? true,
+		verify: options.verify ?? false,
+		verifyOnBuild: options.verifyOnBuild ?? true
+	};
+}
+/**
+* Vite plugin that generates a single typed route module for Analog file routes.
+*/
+function typedRoutes(options = {}) {
+	const resolvedOptions = resolvePluginOptions(options);
+	const workspaceRoot = normalizePath(resolvedOptions.workspaceRoot);
+	let root = "";
+	let command = "serve";
+	let discovery;
+	function isFreshnessCheck() {
+		return resolvedOptions.verify || command === "build" && resolvedOptions.verifyOnBuild;
+	}
+	function resolveDiscoveredFile(filename) {
+		const fromRoot = join(root, filename);
+		if (existsSync(fromRoot)) return fromRoot;
+		return join(workspaceRoot, filename);
+	}
+	function detectSchemas(relativeFilename) {
+		if (!relativeFilename.endsWith(".ts")) return {
+			hasParamsSchema: false,
+			hasQuerySchema: false
+		};
+		try {
+			return detectSchemaExports(readFileSync(resolveDiscoveredFile(relativeFilename), "utf-8"));
+		} catch {
+			return {
+				hasParamsSchema: false,
+				hasQuerySchema: false
+			};
+		}
+	}
+	/**
+	* Ensures the generated route file is imported from an app entry file
+	* so the module augmentation is always part of the TypeScript program.
+	*/
+	function ensureEntryImport() {
+		const entryFiles = ["src/main.ts", "src/main.server.ts"];
+		function importSpecifierFor(entryFile) {
+			const rel = relative(dirname(entryFile), resolvedOptions.outFile).replace(/\.ts$/, "").replace(/\\/g, "/");
+			return rel.startsWith(".") ? rel : "./" + rel;
+		}
+		for (const entryFile of entryFiles) {
+			const entryPath = join(root, entryFile);
+			if (!existsSync(entryPath)) continue;
+			const content = readFileSync(entryPath, "utf-8");
+			const specifier = importSpecifierFor(entryFile);
+			const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			if (new RegExp(`import\\s+['"]${escaped}(\\.ts|\\.js)?['"]`).test(content)) return;
+			if (isFreshnessCheck()) return;
+			const importLine = `import '${specifier}';`;
+			const lines = content.split("\n");
+			let lastImportLine = -1;
+			for (let i = 0; i < lines.length; i++) if (/^import\s/.test(lines[i])) lastImportLine = i;
+			if (lastImportLine >= 0) lines.splice(lastImportLine + 1, 0, importLine);
+			else lines.unshift(importLine);
+			writeFileSync(entryPath, lines.join("\n"), "utf-8");
+			console.log(`[analog] Added route tree import to ${entryFile}`);
+			return;
+		}
+		const specifier = importSpecifierFor("src/main.ts");
+		if (isFreshnessCheck()) return;
+		console.warn(`[analog] Could not find an entry file (src/main.ts or src/main.server.ts) to add the route tree import. Add \`import '${specifier}';\` to your app entry file to ensure typed routing is active.`);
+	}
+	function generate() {
+		const routeFiles = discovery.getRouteFiles();
+		const contentFiles = discovery.getContentFiles();
+		debugTypedRouter("discovered files", {
+			routeFiles: routeFiles.length,
+			contentFiles: contentFiles.length
+		});
+		const manifest = generateRouteManifest([...routeFiles, ...contentFiles], detectSchemas, (filename) => discovery.isAppLocal(filename) ? 0 : 1);
+		const declaration = generateRouteTableDeclaration(manifest);
+		const canonicalFiles = new Set(manifest.routes.map((route) => route.filename));
+		const jsonLdEntries = buildJsonLdEntries(resolveDiscoveredFile, routeFiles.filter((filename) => canonicalFiles.has(filename)), contentFiles.filter((filename) => canonicalFiles.has(filename)));
+		const output = combineGeneratedModules(declaration, generateRouteTreeDeclaration(manifest, { jsonLdFiles: jsonLdEntries.map((entry) => entry.sourceFile) }), resolvedOptions.jsonLdManifest && jsonLdEntries.length > 0 ? generateJsonLdManifestSource(jsonLdEntries, resolvedOptions.outFile) : "");
+		const hardCollisions = manifest.collisions.filter((c) => c.samePriority);
+		if (manifest.collisions.length > 0) debugTypedRouter("route collisions", {
+			total: manifest.collisions.length,
+			hard: hardCollisions.length,
+			collisions: manifest.collisions.map((c) => ({
+				path: c.fullPath,
+				kept: c.keptFile,
+				dropped: c.droppedFile
+			}))
+		});
+		if (hardCollisions.length > 0 && command === "build") {
+			const details = hardCollisions.map((c) => `  '${c.fullPath}': '${c.keptFile}' vs '${c.droppedFile}'`).join("\n");
+			throw new Error(`[analog] Route collisions detected during build:\n${details}\n\nEach route path must be defined by exactly one source file. Remove or rename the conflicting files to resolve the collision.`);
+		}
+		if (manifest.routes.length > 0) console.log(formatManifestSummary(manifest));
+		const outPath = join(root, resolvedOptions.outFile);
+		const outDir = dirname(outPath);
+		const hadExistingOutput = existsSync(outPath);
+		if (!existsSync(outDir)) mkdirSync(outDir, { recursive: true });
+		let existing = "";
+		try {
+			existing = readFileSync(outPath, "utf-8");
+		} catch {}
+		if (output.includes(root)) console.warn(`[analog] Generated route output contains an absolute path prefix (${root}). Route keys and sourceFile values should be workspace-relative.`);
+		const normalizeEndings = (s) => s.replace(/\r\n/g, "\n");
+		if (normalizeEndings(existing) !== normalizeEndings(output)) {
+			debugTypedRouter("route file changed", {
+				outFile: resolvedOptions.outFile,
+				routes: manifest.routes.length,
+				verify: resolvedOptions.verify,
+				verifyOnBuild: resolvedOptions.verifyOnBuild,
+				command
+			});
+			if (resolvedOptions.verify) throw new Error(`[analog] Stale route file detected: ${resolvedOptions.outFile}\nThe checked-in generated route file does not match the current route sources.\nRegenerate route files and commit the updated output.`);
+			writeFileSync(outPath, output, "utf-8");
+			if (command === "build" && resolvedOptions.verifyOnBuild && hadExistingOutput) throw new Error(`[analog] Stale route file detected during build: ${resolvedOptions.outFile}\nThe generated route file was updated to match the current route sources.\nReview the updated output, commit it if it is checked in, and rerun the build.`);
+		}
+	}
+	return {
+		name: "analog-typed-routes",
+		config(config, env) {
+			command = env.command;
+			root = normalizePath(resolve(workspaceRoot, config.root || ".") || ".");
+			discovery = createRouteFileDiscovery({
+				root,
+				workspaceRoot,
+				additionalPagesDirs: resolvedOptions.additionalPagesDirs,
+				additionalContentDirs: resolvedOptions.additionalContentDirs
+			});
+		},
+		buildStart() {
+			generate();
+			if (!isFreshnessCheck()) ensureEntryImport();
+		},
+		configureServer(server) {
+			const regenerate = (path, event) => {
+				if (!discovery.getDiscoveredFileKind(path)) return;
+				debugTypedRouter("watch regenerate", {
+					event,
+					path
+				});
+				discovery.updateDiscoveredFile(path, event);
+				generate();
+			};
+			server.watcher.on("add", (path) => regenerate(path, "add"));
+			server.watcher.on("change", (path) => regenerate(path, "change"));
+			server.watcher.on("unlink", (path) => regenerate(path, "unlink"));
+		}
+	};
+}
+function buildJsonLdEntries(resolveFile, routeFiles, contentFiles) {
+	const entries = [];
+	let importIndex = 0;
+	routeFiles.forEach((filename) => {
+		try {
+			if (!detectJsonLdModuleExports(readFileSync(resolveFile(filename), "utf-8"))) return;
+			entries.push({
+				kind: "module",
+				routePath: filenameToRoutePath(filename),
+				sourceFile: filename,
+				importAlias: `routeModule${importIndex++}`
+			});
+		} catch {}
+	});
+	contentFiles.forEach((filename) => {
+		try {
+			const jsonLd = extractMarkdownJsonLd(readFileSync(resolveFile(filename), "utf-8"));
+			if (jsonLd.length === 0) return;
+			entries.push({
+				kind: "content",
+				routePath: filenameToRoutePath(filename),
+				sourceFile: filename,
+				jsonLd
+			});
+		} catch {}
+	});
+	return entries.sort((a, b) => a.routePath.localeCompare(b.routePath));
+}
+function combineGeneratedModules(...sources) {
+	const imports = [];
+	const seenImports = /* @__PURE__ */ new Set();
+	const bodies = [];
+	for (const source of sources) {
+		const { body, importLines } = splitGeneratedModule(source);
+		for (const importLine of importLines) if (!seenImports.has(importLine)) {
+			seenImports.add(importLine);
+			imports.push(importLine);
+		}
+		if (body.trim()) bodies.push(body.trim());
+	}
+	return [
+		"// This file is auto-generated by @analogjs/platform",
+		"// Do not edit manually",
+		"",
+		...imports.length > 0 ? [...imports, ""] : [],
+		bodies.join("\n\n"),
+		""
+	].join("\n");
+}
+function splitGeneratedModule(source) {
+	const lines = source.split("\n");
+	let index = 0;
+	while (index < lines.length && lines[index].startsWith("//")) index++;
+	while (index < lines.length && lines[index] === "") index++;
+	const importLines = [];
+	while (index < lines.length && lines[index].startsWith("import ")) {
+		importLines.push(lines[index]);
+		index++;
+	}
+	while (index < lines.length && lines[index] === "") index++;
+	return {
+		importLines,
+		body: lines.slice(index).join("\n")
+	};
+}
+//#endregion
+export { typedRoutes };
+
+//# sourceMappingURL=typed-routes-plugin.js.map