@analogjs/platform 3.0.0-alpha.90 → 3.0.0-alpha.92

package/src/server-mode-plugin.js

@@ -1,3 +1,5 @@
+import { resolve } from "node:path";
+import { normalizePath } from "vite";
 //#region packages/platform/src/server-mode-plugin.ts
 var SERVER_MODE_ID = "virtual:@analogjs/platform/server-mode";
 var RESOLVED_SERVER_MODE_ID = `\0${SERVER_MODE_ID}`;
@@ -11,9 +13,19 @@ var RESOLVED_SERVER_MODE_ID = `\0${SERVER_MODE_ID}`;
 * first so the flag is set before any application module evaluates. A text
 * replacement cannot do this because Angular is pre-bundled for SSR.
 */
-function serverModePlugin() {
+function serverModePlugin(entryServer) {
+	let entryServerPath = "";
 	return [{
 		name: "analogjs-server-mode-plugin",
+		configResolved(config) {
+			entryServerPath = normalizePath(resolve(config.root, entryServer ?? "src/main.server.ts"));
+		},
+		transform(code, id, options) {
+			if (options?.ssr && normalizePath(id) === entryServerPath) return {
+				code: `import ${JSON.stringify(SERVER_MODE_ID)};\n${code}`,
+				map: null
+			};
+		},
 		resolveId(id) {
 			return id === "virtual:@analogjs/platform/server-mode" ? RESOLVED_SERVER_MODE_ID : void 0;
 		},

package/src/server-mode-plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"server-mode-plugin.js","names":[],"sources":["../../src/server-mode-plugin.ts"],"sourcesContent":["import { Plugin } from 'vite';\n\nexport const SERVER_MODE_ID = 'virtual:@analogjs/platform/server-mode';\nconst RESOLVED_SERVER_MODE_ID = `\\0${SERVER_MODE_ID}`;\n\n/**\n * Serves a module that sets `globalThis.ngServerMode = true`.\n *\n * Angular decides at provider-creation time whether browser-only features\n * such as event replay apply, and `provideClientHydration()` runs while the\n * app config module evaluates, before `platformServer()` or\n * `provideServerRendering()` set the flag. The SSR entry imports this module\n * first so the flag is set before any application module evaluates. A text\n * replacement cannot do this because Angular is pre-bundled for SSR.\n */\nexport function serverModePlugin(): Plugin[] {\n  return [\n    {\n      name: 'analogjs-server-mode-plugin',\n      resolveId(id) {\n        return id === SERVER_MODE_ID ? RESOLVED_SERVER_MODE_ID : undefined;\n      },\n      load(id) {\n        return id === RESOLVED_SERVER_MODE_ID\n          ? 'globalThis.ngServerMode = true;\\nexport {};\\n'\n          : undefined;\n      },\n    },\n  ];\n}\n"],"mappings":";AAEA,IAAa,iBAAiB;AAC9B,IAAM,0BAA0B,KAAK;;;;;;;;;;;AAYrC,SAAgB,mBAA6B;AAC3C,QAAO,CACL;EACE,MAAM;EACN,UAAU,IAAI;AACZ,UAAO,OAAA,2CAAwB,0BAA0B,KAAA;;EAE3D,KAAK,IAAI;AACP,UAAO,OAAO,0BACV,kDACA,KAAA;;EAEP,CACF"}
+{"version":3,"file":"server-mode-plugin.js","names":[],"sources":["../../src/server-mode-plugin.ts"],"sourcesContent":["import { resolve } from 'node:path';\nimport { Plugin, normalizePath } from 'vite';\n\nexport const SERVER_MODE_ID = 'virtual:@analogjs/platform/server-mode';\nconst RESOLVED_SERVER_MODE_ID = `\\0${SERVER_MODE_ID}`;\n\n/**\n * Serves a module that sets `globalThis.ngServerMode = true`.\n *\n * Angular decides at provider-creation time whether browser-only features\n * such as event replay apply, and `provideClientHydration()` runs while the\n * app config module evaluates, before `platformServer()` or\n * `provideServerRendering()` set the flag. The SSR entry imports this module\n * first so the flag is set before any application module evaluates. A text\n * replacement cannot do this because Angular is pre-bundled for SSR.\n */\nexport function serverModePlugin(entryServer?: string): Plugin[] {\n  let entryServerPath = '';\n\n  return [\n    {\n      name: 'analogjs-server-mode-plugin',\n      configResolved(config) {\n        entryServerPath = normalizePath(\n          resolve(config.root, entryServer ?? 'src/main.server.ts'),\n        );\n      },\n      // Nitro v2 builds `main.server.ts` as the SSR entry directly, so set the\n      // flag there too.\n      transform(code, id, options) {\n        if (options?.ssr && normalizePath(id) === entryServerPath) {\n          return {\n            code: `import ${JSON.stringify(SERVER_MODE_ID)};\\n${code}`,\n            map: null,\n          };\n        }\n        return undefined;\n      },\n      resolveId(id) {\n        return id === SERVER_MODE_ID ? RESOLVED_SERVER_MODE_ID : undefined;\n      },\n      load(id) {\n        return id === RESOLVED_SERVER_MODE_ID\n          ? 'globalThis.ngServerMode = true;\\nexport {};\\n'\n          : undefined;\n      },\n    },\n  ];\n}\n"],"mappings":";;;AAGA,IAAa,iBAAiB;AAC9B,IAAM,0BAA0B,KAAK;;;;;;;;;;;AAYrC,SAAgB,iBAAiB,aAAgC;CAC/D,IAAI,kBAAkB;AAEtB,QAAO,CACL;EACE,MAAM;EACN,eAAe,QAAQ;AACrB,qBAAkB,cAChB,QAAQ,OAAO,MAAM,eAAe,qBAAqB,CAC1D;;EAIH,UAAU,MAAM,IAAI,SAAS;AAC3B,OAAI,SAAS,OAAO,cAAc,GAAG,KAAK,gBACxC,QAAO;IACL,MAAM,UAAU,KAAK,UAAU,eAAe,CAAC,KAAK;IACpD,KAAK;IACN;;EAIL,UAAU,IAAI;AACZ,UAAO,OAAA,2CAAwB,0BAA0B,KAAA;;EAE3D,KAAK,IAAI;AACP,UAAO,OAAO,0BACV,kDACA,KAAA;;EAEP,CACF"}

package/src/lib/json-ld-manifest-plugin.d.ts

@@ -1,41 +0,0 @@
-import { type JsonLdObject } from "./route-manifest.js";
-export type JsonLdModuleManifestEntry = {
-	kind: "module";
-	routePath: string;
-	sourceFile: string;
-	importAlias: string;
-};
-export type JsonLdContentManifestEntry = {
-	kind: "content";
-	routePath: string;
-	sourceFile: string;
-	jsonLd: JsonLdObject[];
-};
-export type JsonLdManifestEntry = JsonLdModuleManifestEntry | JsonLdContentManifestEntry;
-/**
-* Heuristic detector for JSON-LD exports in route modules.
-*
-* This is intentionally regex-based for speed during file scanning.
-* It reliably detects these direct export patterns:
-*
-* - `export const routeJsonLd = ...`
-* - `export const routeMeta = { ..., jsonLd: ... }`
-* - `export const routeJsonLd = (route) => ...` (function form)
-*
-* Known limitations (not detected):
-*
-* - re-exports: `export { routeJsonLd } from './data'`
-* - aliased exports: `export { something as routeJsonLd }`
-* - default exports: `export default { jsonLd: ... }`
-* - indirect assignment: `const data = { jsonLd: ... }; export const routeMeta = data`
-*
-* Known false-positive risks:
-*
-* - comment text containing `export const routeJsonLd`
-* - unrelated `jsonLd` text appearing after `export const routeMeta`
-*
-* Prefer the supported direct export patterns listed above.
-*/
-export declare function detectJsonLdModuleExports(fileContent: string): boolean;
-export declare function extractMarkdownJsonLd(rawContent: string): JsonLdObject[];
-export declare function generateJsonLdManifestSource(entries: JsonLdManifestEntry[], outFile: string): string;

package/src/lib/json-ld-manifest-plugin.js

@@ -1,84 +0,0 @@
-import { normalizeJsonLd } from "./route-manifest.js";
-import { dirname, relative } from "node:path";
-import { normalizePath } from "vite";
-import fm from "front-matter";
-//#region packages/platform/src/lib/json-ld-manifest-plugin.ts
-/**
-* Heuristic detector for JSON-LD exports in route modules.
-*
-* This is intentionally regex-based for speed during file scanning.
-* It reliably detects these direct export patterns:
-*
-* - `export const routeJsonLd = ...`
-* - `export const routeMeta = { ..., jsonLd: ... }`
-* - `export const routeJsonLd = (route) => ...` (function form)
-*
-* Known limitations (not detected):
-*
-* - re-exports: `export { routeJsonLd } from './data'`
-* - aliased exports: `export { something as routeJsonLd }`
-* - default exports: `export default { jsonLd: ... }`
-* - indirect assignment: `const data = { jsonLd: ... }; export const routeMeta = data`
-*
-* Known false-positive risks:
-*
-* - comment text containing `export const routeJsonLd`
-* - unrelated `jsonLd` text appearing after `export const routeMeta`
-*
-* Prefer the supported direct export patterns listed above.
-*/
-function detectJsonLdModuleExports(fileContent) {
-	return /export\s+const\s+routeJsonLd\b/.test(fileContent) || /export\s+const\s+routeMeta\b[\s\S]*?\bjsonLd\b/.test(fileContent);
-}
-function extractMarkdownJsonLd(rawContent) {
-	const { attributes } = fm(rawContent);
-	return normalizeJsonLd(attributes["jsonLd"]);
-}
-function generateJsonLdManifestSource(entries, outFile) {
-	const lines = [];
-	const moduleEntries = entries.filter((entry) => entry.kind === "module");
-	lines.push("// This file is auto-generated by @analogjs/platform");
-	lines.push("// Do not edit manually");
-	lines.push("");
-	lines.push("import type { Graph, Thing, WithContext } from 'schema-dts';");
-	moduleEntries.forEach((entry) => {
-		lines.push(`import * as ${entry.importAlias} from '${toImportPath(outFile, entry.sourceFile)}';`);
-	});
-	lines.push("");
-	lines.push("export type AnalogJsonLdDocument = WithContext<Thing> | Graph | Array<WithContext<Thing>>;");
-	lines.push("export type GeneratedJsonLdManifestEntry = { routePath: string; sourceFile: string; kind: 'module' | 'content'; resolveJsonLd: () => AnalogJsonLdDocument[]; };");
-	lines.push("");
-	lines.push("function normalizeJsonLd(value: unknown): AnalogJsonLdDocument[] {");
-	lines.push("  if (Array.isArray(value)) {");
-	lines.push("    return value.filter((entry): entry is AnalogJsonLdDocument => typeof entry === 'object' && entry !== null && !Array.isArray(entry));");
-	lines.push("  }");
-	lines.push("");
-	lines.push("  return typeof value === 'object' && value !== null ? [value as AnalogJsonLdDocument] : [];");
-	lines.push("}");
-	lines.push("");
-	lines.push("function resolveModuleJsonLd(routeModule: unknown): AnalogJsonLdDocument[] {");
-	lines.push("  const typedRouteModule = routeModule as { routeJsonLd?: unknown; routeMeta?: { jsonLd?: unknown } };");
-	lines.push("  return normalizeJsonLd(typedRouteModule.routeMeta?.jsonLd ?? typedRouteModule.routeJsonLd);");
-	lines.push("}");
-	lines.push("");
-	lines.push("export const routeJsonLdManifest = new Map<string, GeneratedJsonLdManifestEntry>([");
-	entries.forEach((entry) => {
-		if (entry.kind === "module") {
-			lines.push(`  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'module', resolveJsonLd: () => resolveModuleJsonLd(${entry.importAlias}) }],`);
-			return;
-		}
-		lines.push(`  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'content', resolveJsonLd: () => ${JSON.stringify(entry.jsonLd)} }],`);
-	});
-	lines.push("]);");
-	lines.push("");
-	return lines.join("\n");
-}
-function toImportPath(outFile, sourceFile) {
-	const relativePath = normalizePath(relative(dirname(outFile), sourceFile.replace(/^\//, "").replace(/\.(ts|js|analog|ag)$/, "")));
-	if (relativePath.startsWith(".")) return relativePath;
-	return `./${relativePath}`;
-}
-//#endregion
-export { detectJsonLdModuleExports, extractMarkdownJsonLd, generateJsonLdManifestSource };
-
-//# sourceMappingURL=json-ld-manifest-plugin.js.map

package/src/lib/json-ld-manifest-plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-ld-manifest-plugin.js","names":[],"sources":["../../../src/lib/json-ld-manifest-plugin.ts"],"sourcesContent":["import fm from 'front-matter';\nimport { normalizePath } from 'vite';\nimport { dirname, relative } from 'node:path';\n\nimport { normalizeJsonLd, type JsonLdObject } from './route-manifest.js';\n\nexport type JsonLdModuleManifestEntry = {\n  kind: 'module';\n  routePath: string;\n  sourceFile: string;\n  importAlias: string;\n};\n\nexport type JsonLdContentManifestEntry = {\n  kind: 'content';\n  routePath: string;\n  sourceFile: string;\n  jsonLd: JsonLdObject[];\n};\n\nexport type JsonLdManifestEntry =\n  | JsonLdModuleManifestEntry\n  | JsonLdContentManifestEntry;\n\n/**\n * Heuristic detector for JSON-LD exports in route modules.\n *\n * This is intentionally regex-based for speed during file scanning.\n * It reliably detects these direct export patterns:\n *\n * - `export const routeJsonLd = ...`\n * - `export const routeMeta = { ..., jsonLd: ... }`\n * - `export const routeJsonLd = (route) => ...` (function form)\n *\n * Known limitations (not detected):\n *\n * - re-exports: `export { routeJsonLd } from './data'`\n * - aliased exports: `export { something as routeJsonLd }`\n * - default exports: `export default { jsonLd: ... }`\n * - indirect assignment: `const data = { jsonLd: ... }; export const routeMeta = data`\n *\n * Known false-positive risks:\n *\n * - comment text containing `export const routeJsonLd`\n * - unrelated `jsonLd` text appearing after `export const routeMeta`\n *\n * Prefer the supported direct export patterns listed above.\n */\nexport function detectJsonLdModuleExports(fileContent: string): boolean {\n  return (\n    /export\\s+const\\s+routeJsonLd\\b/.test(fileContent) ||\n    /export\\s+const\\s+routeMeta\\b[\\s\\S]*?\\bjsonLd\\b/.test(fileContent)\n  );\n}\n\nexport function extractMarkdownJsonLd(rawContent: string): JsonLdObject[] {\n  const { attributes } = fm<Record<string, unknown>>(rawContent);\n  return normalizeJsonLd(attributes['jsonLd']);\n}\n\nexport function generateJsonLdManifestSource(\n  entries: JsonLdManifestEntry[],\n  outFile: string,\n): string {\n  const lines: string[] = [];\n  const moduleEntries = entries.filter(\n    (entry): entry is JsonLdModuleManifestEntry => entry.kind === 'module',\n  );\n\n  lines.push('// This file is auto-generated by @analogjs/platform');\n  lines.push('// Do not edit manually');\n  lines.push('');\n\n  lines.push(\"import type { Graph, Thing, WithContext } from 'schema-dts';\");\n\n  moduleEntries.forEach((entry) => {\n    lines.push(\n      `import * as ${entry.importAlias} from '${toImportPath(outFile, entry.sourceFile)}';`,\n    );\n  });\n\n  lines.push('');\n  lines.push(\n    'export type AnalogJsonLdDocument = WithContext<Thing> | Graph | Array<WithContext<Thing>>;',\n  );\n  lines.push(\n    \"export type GeneratedJsonLdManifestEntry = { routePath: string; sourceFile: string; kind: 'module' | 'content'; resolveJsonLd: () => AnalogJsonLdDocument[]; };\",\n  );\n  lines.push('');\n  lines.push(\n    'function normalizeJsonLd(value: unknown): AnalogJsonLdDocument[] {',\n  );\n  lines.push('  if (Array.isArray(value)) {');\n  lines.push(\n    \"    return value.filter((entry): entry is AnalogJsonLdDocument => typeof entry === 'object' && entry !== null && !Array.isArray(entry));\",\n  );\n  lines.push('  }');\n  lines.push('');\n  lines.push(\n    \"  return typeof value === 'object' && value !== null ? [value as AnalogJsonLdDocument] : [];\",\n  );\n  lines.push('}');\n  lines.push('');\n  lines.push(\n    'function resolveModuleJsonLd(routeModule: unknown): AnalogJsonLdDocument[] {',\n  );\n  lines.push(\n    '  const typedRouteModule = routeModule as { routeJsonLd?: unknown; routeMeta?: { jsonLd?: unknown } };',\n  );\n  lines.push(\n    // Match runtime precedence (mergeRouteJsonLdIntoRouteMeta in routes.ts):\n    // routeMeta.jsonLd wins over standalone routeJsonLd.\n    '  return normalizeJsonLd(typedRouteModule.routeMeta?.jsonLd ?? typedRouteModule.routeJsonLd);',\n  );\n  lines.push('}');\n  lines.push('');\n  lines.push(\n    'export const routeJsonLdManifest = new Map<string, GeneratedJsonLdManifestEntry>([',\n  );\n\n  entries.forEach((entry) => {\n    if (entry.kind === 'module') {\n      lines.push(\n        `  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'module', resolveJsonLd: () => resolveModuleJsonLd(${entry.importAlias}) }],`,\n      );\n      return;\n    }\n\n    lines.push(\n      `  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'content', resolveJsonLd: () => ${JSON.stringify(entry.jsonLd)} }],`,\n    );\n  });\n\n  lines.push(']);');\n  lines.push('');\n\n  return lines.join('\\n');\n}\n\nfunction toImportPath(outFile: string, sourceFile: string): string {\n  // JSON-LD entries are emitted inside the same generated route module, so\n  // imports are always resolved relative to that single output file.\n  const fromDir = dirname(outFile);\n  const sourceNoExt = sourceFile\n    .replace(/^\\//, '')\n    .replace(/\\.(ts|js|analog|ag)$/, '');\n  const relativePath = normalizePath(relative(fromDir, sourceNoExt));\n\n  if (relativePath.startsWith('.')) {\n    return relativePath;\n  }\n\n  return `./${relativePath}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,0BAA0B,aAA8B;AACtE,QACE,iCAAiC,KAAK,YAAY,IAClD,iDAAiD,KAAK,YAAY;;AAItE,SAAgB,sBAAsB,YAAoC;CACxE,MAAM,EAAE,eAAe,GAA4B,WAAW;AAC9D,QAAO,gBAAgB,WAAW,UAAU;;AAG9C,SAAgB,6BACd,SACA,SACQ;CACR,MAAM,QAAkB,EAAE;CAC1B,MAAM,gBAAgB,QAAQ,QAC3B,UAA8C,MAAM,SAAS,SAC/D;AAED,OAAM,KAAK,uDAAuD;AAClE,OAAM,KAAK,0BAA0B;AACrC,OAAM,KAAK,GAAG;AAEd,OAAM,KAAK,+DAA+D;AAE1E,eAAc,SAAS,UAAU;AAC/B,QAAM,KACJ,eAAe,MAAM,YAAY,SAAS,aAAa,SAAS,MAAM,WAAW,CAAC,IACnF;GACD;AAEF,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,6FACD;AACD,OAAM,KACJ,kKACD;AACD,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,qEACD;AACD,OAAM,KAAK,gCAAgC;AAC3C,OAAM,KACJ,2IACD;AACD,OAAM,KAAK,MAAM;AACjB,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,+FACD;AACD,OAAM,KAAK,IAAI;AACf,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,+EACD;AACD,OAAM,KACJ,yGACD;AACD,OAAM,KAGJ,gGACD;AACD,OAAM,KAAK,IAAI;AACf,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,qFACD;AAED,SAAQ,SAAS,UAAU;AACzB,MAAI,MAAM,SAAS,UAAU;AAC3B,SAAM,KACJ,OAAO,MAAM,UAAU,mBAAmB,MAAM,UAAU,kBAAkB,MAAM,WAAW,8DAA8D,MAAM,YAAY,OAC9K;AACD;;AAGF,QAAM,KACJ,OAAO,MAAM,UAAU,mBAAmB,MAAM,UAAU,kBAAkB,MAAM,WAAW,2CAA2C,KAAK,UAAU,MAAM,OAAO,CAAC,MACtK;GACD;AAEF,OAAM,KAAK,MAAM;AACjB,OAAM,KAAK,GAAG;AAEd,QAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,aAAa,SAAiB,YAA4B;CAOjE,MAAM,eAAe,cAAc,SAJnB,QAAQ,QAAQ,EACZ,WACjB,QAAQ,OAAO,GAAG,CAClB,QAAQ,wBAAwB,GAAG,CAC2B,CAAC;AAElE,KAAI,aAAa,WAAW,IAAI,CAC9B,QAAO;AAGT,QAAO,KAAK"}

package/src/lib/route-generation-plugin.d.ts

@@ -1,3 +0,0 @@
-import type { Plugin } from "vite";
-import type { Options } from "./options.js";
-export declare function routeGenerationPlugin(options?: Options): Plugin;

package/src/lib/route-generation-plugin.js

@@ -1,45 +0,0 @@
-import { debugTypedRouter } from "./utils/debug.js";
-import { typedRoutes } from "./typed-routes-plugin.js";
-//#region packages/platform/src/lib/route-generation-plugin.ts
-function resolveTypedRouterOptions(experimental) {
-	const typedRouter = experimental?.typedRouter;
-	if (!typedRouter) return {
-		enabled: false,
-		options: {}
-	};
-	if (typedRouter === true) return {
-		enabled: true,
-		options: { jsonLdManifest: true }
-	};
-	return {
-		enabled: true,
-		options: {
-			...typedRouter,
-			jsonLdManifest: typedRouter.jsonLdManifest ?? true
-		}
-	};
-}
-function routeGenerationPlugin(options) {
-	const { enabled, options: typedRouterOptions } = resolveTypedRouterOptions(options?.experimental);
-	if (!enabled) {
-		debugTypedRouter("disabled by experimental.typedRouter === false");
-		return { name: "analog-route-generation-disabled" };
-	}
-	const pluginOptions = {
-		...typedRouterOptions,
-		workspaceRoot: options?.workspaceRoot,
-		additionalPagesDirs: options?.additionalPagesDirs,
-		additionalContentDirs: options?.additionalContentDirs
-	};
-	debugTypedRouter("enabled", {
-		outFile: pluginOptions.outFile,
-		jsonLdManifest: pluginOptions.jsonLdManifest,
-		additionalPagesDirs: pluginOptions.additionalPagesDirs,
-		additionalContentDirs: pluginOptions.additionalContentDirs
-	});
-	return typedRoutes(pluginOptions);
-}
-//#endregion
-export { routeGenerationPlugin };
-
-//# sourceMappingURL=route-generation-plugin.js.map

package/src/lib/route-generation-plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"route-generation-plugin.js","names":[],"sources":["../../../src/lib/route-generation-plugin.ts"],"sourcesContent":["import type { Plugin } from 'vite';\n\nimport type { Options, TypedRouterOptions } from './options.js';\nimport {\n  typedRoutes,\n  type TypedRoutesPluginOptions,\n} from './typed-routes-plugin.js';\nimport { debugTypedRouter } from './utils/debug.js';\n\nfunction resolveTypedRouterOptions(experimental: Options['experimental']): {\n  enabled: boolean;\n  options: TypedRouterOptions;\n} {\n  const typedRouter = experimental?.typedRouter;\n  if (!typedRouter) {\n    return { enabled: false, options: {} };\n  }\n  if (typedRouter === true) {\n    return { enabled: true, options: { jsonLdManifest: true } };\n  }\n  return {\n    enabled: true,\n    options: {\n      ...typedRouter,\n      jsonLdManifest: typedRouter.jsonLdManifest ?? true,\n    },\n  };\n}\n\nexport function routeGenerationPlugin(options?: Options): Plugin {\n  const { enabled, options: typedRouterOptions } = resolveTypedRouterOptions(\n    options?.experimental,\n  );\n\n  if (!enabled) {\n    debugTypedRouter('disabled by experimental.typedRouter === false');\n    return {\n      name: 'analog-route-generation-disabled',\n    };\n  }\n\n  const pluginOptions: TypedRoutesPluginOptions = {\n    ...typedRouterOptions,\n    workspaceRoot: options?.workspaceRoot,\n    additionalPagesDirs: options?.additionalPagesDirs,\n    additionalContentDirs: options?.additionalContentDirs,\n  };\n  debugTypedRouter('enabled', {\n    outFile: pluginOptions.outFile,\n    jsonLdManifest: pluginOptions.jsonLdManifest,\n    additionalPagesDirs: pluginOptions.additionalPagesDirs,\n    additionalContentDirs: pluginOptions.additionalContentDirs,\n  });\n\n  return typedRoutes(pluginOptions);\n}\n"],"mappings":";;;AASA,SAAS,0BAA0B,cAGjC;CACA,MAAM,cAAc,cAAc;AAClC,KAAI,CAAC,YACH,QAAO;EAAE,SAAS;EAAO,SAAS,EAAE;EAAE;AAExC,KAAI,gBAAgB,KAClB,QAAO;EAAE,SAAS;EAAM,SAAS,EAAE,gBAAgB,MAAM;EAAE;AAE7D,QAAO;EACL,SAAS;EACT,SAAS;GACP,GAAG;GACH,gBAAgB,YAAY,kBAAkB;GAC/C;EACF;;AAGH,SAAgB,sBAAsB,SAA2B;CAC/D,MAAM,EAAE,SAAS,SAAS,uBAAuB,0BAC/C,SAAS,aACV;AAED,KAAI,CAAC,SAAS;AACZ,mBAAiB,iDAAiD;AAClE,SAAO,EACL,MAAM,oCACP;;CAGH,MAAM,gBAA0C;EAC9C,GAAG;EACH,eAAe,SAAS;EACxB,qBAAqB,SAAS;EAC9B,uBAAuB,SAAS;EACjC;AACD,kBAAiB,WAAW;EAC1B,SAAS,cAAc;EACvB,gBAAgB,cAAc;EAC9B,qBAAqB,cAAc;EACnC,uBAAuB,cAAc;EACtC,CAAC;AAEF,QAAO,YAAY,cAAc"}