@xndrjs/i18n 0.7.0 → 0.8.0

package/src/codegen/emit/namespace-loaders-file.test.ts

@@ -6,33 +6,6 @@ const projectRoot = "/project";
 const loadersOutputPath = path.join(projectRoot, "src/i18n/namespace-loaders.generated.ts");
 
 describe("formatNamespaceLoadersFile", () => {
-  it("emits flat loaders in canonical mode", () => {
-    const output = formatNamespaceLoadersFile({
-      loadersOutputPath,
-      lazyEntries: [
-        {
-          namespace: "billing",
-          filePath: "src/i18n/translations/billing.json",
-          absolutePath: path.join(projectRoot, "src/i18n/translations/billing.json"),
-        },
-      ],
-      schemaTypeName: "AppSchema",
-      paramsTypeName: "AppParams",
-      localeTypeName: "AppLocale",
-      localeFallbackConstName: "LOCALE_FALLBACK",
-      hasLocaleFallback: false,
-      typesModule: "i18n-types.generated",
-      importExtension: "none",
-      projectRoot,
-      delivery: "canonical",
-    });
-
-    expect(output).toContain("[K in LazyNamespace]: () => Promise<AppSchema[K]>");
-    expect(output).toContain(
-      "billing: () => import('./translations/billing.json').then((m) => m.default),"
-    );
-  });
-
   it("emits ns(locale) loaders in split mode", () => {
     const output = formatNamespaceLoadersFile({
       loadersOutputPath,
@@ -54,14 +27,10 @@ describe("formatNamespaceLoadersFile", () => {
         },
       ],
       schemaTypeName: "AppSchema",
-      paramsTypeName: "AppParams",
       localeTypeName: "AppLocale",
-      localeFallbackConstName: "LOCALE_FALLBACK",
-      hasLocaleFallback: true,
       typesModule: "i18n-types.generated",
       importExtension: "none",
       projectRoot,
-      isSingle: false,
       delivery: "split-by-locale",
       requestLocales: ["en", "it", "de-CH"],
       splitPathsByNamespace: {
@@ -83,6 +52,9 @@ describe("formatNamespaceLoadersFile", () => {
       },
     });
 
+    expect(output).toContain(
+      "import type { AppSchema, LazyNamespace, AppLocale } from './i18n-types.generated';"
+    );
     expect(output).toContain("[K in LazyNamespace]: (locale: AppLocale) => Promise<AppSchema[K]>;");
     expect(output).toContain("billing: (locale) => {");
     expect(output).toContain('case "en":');
@@ -101,39 +73,6 @@ describe("formatNamespaceLoadersFile", () => {
     expect(output.match(/from '\.\/i18n-types\.generated'/g)?.length).toBe(1);
   });
 
-  it("emits locale-scoped loaders for single mode in split delivery", () => {
-    const output = formatNamespaceLoadersFile({
-      loadersOutputPath,
-      lazyEntries: [
-        {
-          namespace: "default",
-          filePath: "src/i18n/translations/translations.json",
-          absolutePath: path.join(projectRoot, "src/i18n/translations/translations.json"),
-        },
-      ],
-      schemaTypeName: "AppSchema",
-      paramsTypeName: "AppParams",
-      localeTypeName: "AppLocale",
-      localeFallbackConstName: "LOCALE_FALLBACK",
-      hasLocaleFallback: true,
-      typesModule: "i18n-types.generated",
-      importExtension: "none",
-      projectRoot,
-      isSingle: true,
-      delivery: "split-by-locale",
-      requestLocales: ["en", "it"],
-      splitPathsByNamespace: {
-        default: {
-          en: "src/i18n/generated/translations/translations.en.json",
-          it: "src/i18n/generated/translations/translations.it.json",
-        },
-      },
-    });
-
-    expect(output).toContain("[K in LazyNamespace]: (locale: AppLocale) => Promise<AppSchema>;");
-    expect(output).toContain('export const defaultLazyNamespaces = ["default"] as const;');
-  });
-
   it("throws when a split path is missing", () => {
     expect(() =>
       formatNamespaceLoadersFile({
@@ -146,10 +85,7 @@ describe("formatNamespaceLoadersFile", () => {
           },
         ],
         schemaTypeName: "AppSchema",
-        paramsTypeName: "AppParams",
         localeTypeName: "AppLocale",
-        localeFallbackConstName: "LOCALE_FALLBACK",
-        hasLocaleFallback: false,
         typesModule: "i18n-types.generated",
         importExtension: "none",
         projectRoot,
@@ -180,14 +116,10 @@ describe("formatNamespaceLoadersFile", () => {
         },
       ],
       schemaTypeName: "AppSchema",
-      paramsTypeName: "AppParams",
       localeTypeName: "AppLocale",
-      localeFallbackConstName: "LOCALE_FALLBACK",
-      hasLocaleFallback: true,
       typesModule: "i18n-types.generated",
       importExtension: "none",
       projectRoot,
-      isSingle: false,
       delivery: "custom",
       deliveryAreaTypeName: "AppDeliveryArea",
       deliveryAreaNames: ["eu", "us"],
@@ -203,6 +135,9 @@ describe("formatNamespaceLoadersFile", () => {
       },
     });
 
+    expect(output).toContain(
+      "import type { AppSchema, LazyNamespace, AppDeliveryArea } from './i18n-types.generated';"
+    );
     expect(output).toContain(
       "[K in LazyNamespace]: (area: AppDeliveryArea) => Promise<AppSchema[K]>;"
     );
@@ -232,10 +167,7 @@ describe("formatNamespaceLoadersFile", () => {
           },
         ],
         schemaTypeName: "AppSchema",
-        paramsTypeName: "AppParams",
         localeTypeName: "AppLocale",
-        localeFallbackConstName: "LOCALE_FALLBACK",
-        hasLocaleFallback: false,
         typesModule: "i18n-types.generated",
         importExtension: "none",
         projectRoot,
@@ -250,4 +182,70 @@ describe("formatNamespaceLoadersFile", () => {
       })
     ).toThrow('[Codegen Error] Missing split path for namespace "billing", area "us".');
   });
+
+  it("emits fetch loaders that pass a resource id to fetchImpl", () => {
+    const output = formatNamespaceLoadersFile({
+      loadersOutputPath,
+      lazyEntries: [
+        {
+          namespace: "billing",
+          filePath: "src/i18n/translations/billing.json",
+          absolutePath: path.join(projectRoot, "src/i18n/translations/billing.json"),
+        },
+      ],
+      schemaTypeName: "AppSchema",
+      localeTypeName: "AppLocale",
+      typesModule: "i18n-types.generated",
+      importExtension: "none",
+      projectRoot,
+      delivery: "split-by-locale",
+      requestLocales: ["en", "it"],
+      loaderStrategy: "fetch",
+      splitPathsByNamespace: {
+        billing: {
+          en: "src/i18n/generated/translations/billing.en.json",
+          it: "src/i18n/generated/translations/billing.it.json",
+        },
+      },
+    });
+
+    expect(output).toContain("export function createNamespaceLoaders");
+    expect(output).toContain("import type { FetchArtifact }");
+    expect(output).toContain(
+      'fetchImpl({ locale, namespace: "billing" }) as Promise<AppSchema["billing"]>'
+    );
+  });
+
+  it("emits custom-delivery fetch loaders with locale + area", () => {
+    const output = formatNamespaceLoadersFile({
+      loadersOutputPath,
+      lazyEntries: [
+        {
+          namespace: "billing",
+          filePath: "src/i18n/translations/billing.json",
+          absolutePath: path.join(projectRoot, "src/i18n/translations/billing.json"),
+        },
+      ],
+      schemaTypeName: "AppSchema",
+      localeTypeName: "AppLocale",
+      typesModule: "i18n-types.generated",
+      importExtension: "none",
+      projectRoot,
+      delivery: "custom",
+      deliveryAreaTypeName: "AppDeliveryArea",
+      deliveryAreaNames: ["eu", "us"],
+      loaderStrategy: "fetch",
+      splitPathsByNamespace: {
+        billing: {
+          eu: "src/i18n/generated/translations/billing.eu.json",
+          us: "src/i18n/generated/translations/billing.us.json",
+        },
+      },
+    });
+
+    expect(output).toContain("(area, { locale }) =>");
+    expect(output).toContain(
+      'fetchImpl({ locale, namespace: "billing", area }) as Promise<AppSchema["billing"]>'
+    );
+  });
 });

package/src/codegen/emit/namespace-loaders-file.ts

@@ -1,29 +1,26 @@
 import path from "node:path";
-import type { DeliveryMode } from "../codegen-config-schema.js";
+import type { DeliveryMode, LoaderStrategy } from "../codegen-config-schema.js";
 import { GENERATED_FILE_BANNER, toImportPath, toRelativeModuleImport } from "../paths.js";
 import type { ImportExtension, NamespaceEntry } from "../types.js";
 
 /**
  * Emits the generated `namespace-loaders.generated.ts` module: dynamic `import()`
- * functions for lazy-loaded namespaces, shaped by delivery mode.
+ * or injectable `fetchImpl(resourceId)` loaders, shaped by delivery mode.
  */
 export interface NamespaceLoadersFileOptions {
   loadersOutputPath: string;
   lazyEntries: (NamespaceEntry & { absolutePath: string })[];
   schemaTypeName: string;
-  paramsTypeName: string;
   localeTypeName: string;
-  localeFallbackConstName: string;
-  hasLocaleFallback: boolean;
   typesModule: string;
   importExtension: ImportExtension;
   projectRoot: string;
-  isSingle?: boolean;
-  delivery?: DeliveryMode;
+  delivery: DeliveryMode;
   splitPathsByNamespace?: Record<string, Record<string, string>>;
   requestLocales?: readonly string[];
   deliveryAreaTypeName?: string;
   deliveryAreaNames?: readonly string[];
+  loaderStrategy?: LoaderStrategy;
 }
 
 interface PartitionedNamespaceLoadersParams {
@@ -44,28 +41,97 @@ function formatPartitionedTypesImport(
   options: NamespaceLoadersFileOptions,
   paramTypeName: string
 ): string {
-  const { schemaTypeName, paramsTypeName, localeTypeName, typesModule, importExtension, isSingle } =
-    options;
+  const { schemaTypeName, typesModule, importExtension } = options;
+  return `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
+}
 
-  if (isSingle) {
-    return `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName}, ${localeTypeName} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
-  }
+function formatImportCase(
+  loadersOutputPath: string,
+  projectRoot: string,
+  splitRelativePath: string
+): string {
+  const importPath = toImportPath(loadersOutputPath, path.resolve(projectRoot, splitRelativePath));
+  return `return import('${importPath}.json').then((m) => m.default);`;
+}
 
-  const paramTypeImport = paramTypeName === localeTypeName ? "" : `, ${paramTypeName}`;
-  return `import type { ${localeTypeName}, ${paramsTypeName}, ${schemaTypeName}, LazyNamespace${paramTypeImport} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
+function indentBlock(text: string, spaces: number): string {
+  const pad = " ".repeat(spaces);
+  return text
+    .split("\n")
+    .map((line) => (line.length === 0 ? line : `${pad}${line}`))
+    .join("\n");
 }
 
-function formatSwitchDefaultCase(namespace: string, paramName: string): string {
-  return (
-    `      default:\n` +
-    `        throw new Error(\`[i18n] No translation artifact for namespace ${JSON.stringify(namespace)} and ${paramName} "\${String(${paramName})}".\`);\n`
+function formatImportNamespaceLoaderEntry(options: {
+  namespace: string;
+  paramName: string;
+  partitionKeys: readonly string[];
+  splitPathsByNamespace: Record<string, Record<string, string>>;
+  loadersOutputPath: string;
+  projectRoot: string;
+}): string {
+  const {
+    namespace,
+    paramName,
+    partitionKeys,
+    splitPathsByNamespace,
+    loadersOutputPath,
+    projectRoot,
+  } = options;
+
+  const caseBodies = partitionKeys.map((partitionKey) => {
+    const splitRelativePath = splitPathsByNamespace[namespace]?.[partitionKey];
+    if (!splitRelativePath) {
+      throw new Error(
+        `[Codegen Error] Missing split path for namespace "${namespace}", ${paramName} "${partitionKey}".`
+      );
+    }
+    const body = formatImportCase(loadersOutputPath, projectRoot, splitRelativePath);
+    return [`case ${JSON.stringify(partitionKey)}:`, `  ${body}`].join("\n");
+  });
+
+  const switchBody = [
+    ...caseBodies,
+    `default:`,
+    `  throw new Error(\`[i18n] No translation artifact for namespace ${JSON.stringify(namespace)} and ${paramName} "\${String(${paramName})}".\`);`,
+  ].join("\n");
+
+  const entry = [
+    `${namespace}: (${paramName}) => {`,
+    `  switch (${paramName}) {`,
+    indentBlock(switchBody, 4),
+    `  }`,
+    `},`,
+  ].join("\n");
+
+  return indentBlock(entry, 2);
+}
+
+/** Fetch loaders forward a resource id; URL mapping is left to `fetchImpl`. */
+function formatFetchNamespaceLoaderEntry(options: {
+  namespace: string;
+  paramName: string;
+  schemaTypeName: string;
+  delivery: DeliveryMode;
+}): string {
+  const { namespace, paramName, schemaTypeName, delivery } = options;
+  const nsLiteral = JSON.stringify(namespace);
+  const resourceId =
+    delivery === "custom"
+      ? `{ locale, namespace: ${nsLiteral}, area }`
+      : `{ locale, namespace: ${nsLiteral} }`;
+
+  // Custom: partition is area; locale comes from load() context.
+  // Split-by-locale: partition is locale (second arg unused).
+  const signature = delivery === "custom" ? `(${paramName}, { locale })` : `(${paramName})`;
+
+  return indentBlock(
+    `${namespace}: ${signature} =>\n` +
+      `  fetchImpl(${resourceId}) as Promise<${schemaTypeName}[${nsLiteral}]>,`,
+    4
   );
 }
 
-/**
- * Each namespace gets a function that dynamic-imports the JSON for the given
- * partition key (locale or area) via a switch.
- */
 function formatPartitionedNamespaceLoadersFile(
   options: NamespaceLoadersFileOptions,
   params: PartitionedNamespaceLoadersParams
@@ -76,97 +142,88 @@ function formatPartitionedNamespaceLoadersFile(
     lazyEntries,
     schemaTypeName,
     projectRoot,
+    delivery,
     splitPathsByNamespace = {},
-    isSingle = false,
   } = options;
+  const loaderStrategy = options.loaderStrategy ?? "import";
 
-  const loaderValueType = isSingle ? schemaTypeName : `${schemaTypeName}[K]`;
-
+  const loaderValueType = `${schemaTypeName}[K]`;
   const typesImport = formatPartitionedTypesImport(options, paramTypeName);
-  const loaderEntries = lazyEntries
-    .map((entry) => {
-      const switchCases = partitionKeys
-        .map((partitionKey) => {
-          const splitRelativePath = splitPathsByNamespace[entry.namespace]?.[partitionKey];
-          if (!splitRelativePath) {
-            throw new Error(
-              `[Codegen Error] Missing split path for namespace "${entry.namespace}", ${paramName} "${partitionKey}".`
-            );
-          }
-          const importPath = toImportPath(
-            loadersOutputPath,
-            path.resolve(projectRoot, splitRelativePath)
-          );
-          return (
-            `      case ${JSON.stringify(partitionKey)}:\n` +
-            `        return import('${importPath}.json').then((m) => m.default);`
-          );
+
+  if (loaderStrategy === "fetch") {
+    // Fetch loaders ignore partition-key switches: the resource id is enough for the app.
+    const fetchLoadersType = `{\n  [K in LazyNamespace]: (${
+      delivery === "custom"
+        ? `${paramName}: ${paramTypeName}, context: { locale: string }`
+        : `${paramName}: ${paramTypeName}`
+    }) => Promise<${loaderValueType}>;\n}`;
+
+    const loaderEntries = lazyEntries
+      .map((entry) =>
+        formatFetchNamespaceLoaderEntry({
+          namespace: entry.namespace,
+          paramName,
+          schemaTypeName,
+          delivery,
         })
-        .join("\n");
-
-      return (
-        `  ${entry.namespace}: (${paramName}) => {\n` +
-        `    switch (${paramName}) {\n${switchCases}\n` +
-        `${formatSwitchDefaultCase(entry.namespace, paramName)}` +
-        `    }\n` +
-        `  },`
-      );
-    })
-    .join("\n");
+      )
+      .join("\n");
 
-  return (
-    `${GENERATED_FILE_BANNER}` +
-    typesImport +
-    `export const namespaceLoaders: {\n` +
-    `  [K in LazyNamespace]: (${paramName}: ${paramTypeName}) => Promise<${loaderValueType}>;\n` +
-    `} = {\n${loaderEntries}\n};\n` +
-    `\n` +
-    `export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;\n`
-  );
-}
+    return (
+      `${GENERATED_FILE_BANNER}` +
+      `import type { FetchArtifact } from '@xndrjs/i18n';\n` +
+      typesImport +
+      `export type NamespaceLoaders = ${fetchLoadersType};\n\n` +
+      `/** Build loaders that resolve artifacts via the injected {@link FetchArtifact} (resource id only). */\n` +
+      `export function createNamespaceLoaders(fetchImpl: FetchArtifact): NamespaceLoaders {\n` +
+      `  return {\n${loaderEntries}\n  };\n` +
+      `}\n\n` +
+      `export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;\n`
+    );
+  }
 
-/** Emits lazy loaders for canonical delivery: one dynamic import per namespace. */
-function formatCanonicalNamespaceLoadersFile(options: NamespaceLoadersFileOptions): string {
-  const { loadersOutputPath, lazyEntries, schemaTypeName, typesModule, importExtension } = options;
-  const typesImport = toRelativeModuleImport(typesModule, importExtension);
   const loaderEntries = lazyEntries
-    .map((entry) => {
-      const importPath = toImportPath(loadersOutputPath, entry.absolutePath);
-      return `  ${entry.namespace}: () => import('${importPath}.json').then((m) => m.default),`;
-    })
+    .map((entry) =>
+      formatImportNamespaceLoaderEntry({
+        namespace: entry.namespace,
+        paramName,
+        partitionKeys,
+        splitPathsByNamespace,
+        loadersOutputPath,
+        projectRoot,
+      })
+    )
     .join("\n");
 
+  // Import loaders only use the partition key; context is accepted for a uniform NamespaceLoader shape.
+  const importLoadersType = `{\n  [K in LazyNamespace]: (${paramName}: ${paramTypeName}) => Promise<${loaderValueType}>;\n}`;
+
   return (
     `${GENERATED_FILE_BANNER}` +
-    `import type { ${schemaTypeName}, LazyNamespace } from '${typesImport}';\n\n` +
-    `export const namespaceLoaders: {\n` +
-    `  [K in LazyNamespace]: () => Promise<${schemaTypeName}[K]>;\n` +
-    `} = {\n${loaderEntries}\n};\n`
+    typesImport +
+    `export const namespaceLoaders: ${importLoadersType} = {\n${loaderEntries}\n};\n` +
+    `\n` +
+    `export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;\n`
   );
 }
 
 /**
- * Builds `namespace-loaders.generated.ts` for the configured delivery mode:
- * canonical, split-by-locale, or custom areas.
+ * Builds `namespace-loaders.generated.ts` for split-by-locale or custom delivery areas.
  */
 export function formatNamespaceLoadersFile(options: NamespaceLoadersFileOptions): string {
-  const delivery = options.delivery ?? "canonical";
-  if (delivery === "split-by-locale") {
+  if (options.delivery === "split-by-locale") {
     return formatPartitionedNamespaceLoadersFile(options, {
       partitionKeys: options.requestLocales ?? [],
       paramName: "locale",
       paramTypeName: options.localeTypeName,
     });
   }
-  if (delivery === "custom") {
-    if (!options.deliveryAreaTypeName) {
-      throw new Error("[Codegen Error] deliveryAreaTypeName is required for custom delivery.");
-    }
-    return formatPartitionedNamespaceLoadersFile(options, {
-      partitionKeys: options.deliveryAreaNames ?? [],
-      paramName: "area",
-      paramTypeName: options.deliveryAreaTypeName,
-    });
+  if (!options.deliveryAreaTypeName) {
+    throw new Error("[Codegen Error] deliveryAreaTypeName is required for custom delivery.");
   }
-  return formatCanonicalNamespaceLoadersFile(options);
+  return formatPartitionedNamespaceLoadersFile(options, {
+    partitionKeys: options.deliveryAreaNames ?? [],
+    paramName: "area",
+    paramTypeName: options.deliveryAreaTypeName,
+  });
 }

package/src/codegen/emit/types-file.test.ts

@@ -6,9 +6,8 @@ const projectRoot = "/project";
 const typesOutputPath = path.join(projectRoot, "src/i18n/generated/i18n-types.generated.ts");
 
 describe("formatTypesFile", () => {
-  it("emits explicit Partial schema types for multi-namespace", () => {
+  it("emits explicit Partial schema types and lazy aliases", () => {
     const output = formatTypesFile({
-      isSingle: false,
       entries: [
         { namespace: "default", filePath: "src/i18n/translations/default.json" },
         { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
@@ -29,46 +28,23 @@ describe("formatTypesFile", () => {
           invoice_summary: "{ count: number }",
         },
       },
-      requestLocaleUnion: "'en' | 'it'",
-      hasLazy: true,
-      loadOnInitSet: new Set(["default"]),
-      lazyEntries: [{ namespace: "billing", filePath: "src/i18n/translations/billing.yaml" }],
+      requestLocales: ["en", "it"],
+      lazyEntries: [
+        { namespace: "default", filePath: "src/i18n/translations/default.json" },
+        { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
+      ],
     });
 
     expect(output).toContain("login_button: Partial<Record<AppLocale, string>>;");
     expect(output).toContain("invoice_summary: Partial<Record<AppLocale, string>>;");
-  });
-
-  it("emits explicit Partial schema types for single-file mode", () => {
-    const output = formatTypesFile({
-      isSingle: true,
-      entries: [{ namespace: "translations", filePath: "src/i18n/translations/translations.yaml" }],
-      projectRoot,
-      typesOutputPath,
-      paramsTypeName: "AppParams",
-      schemaTypeName: "AppSchema",
-      localeTypeName: "AppLocale",
-      localeFallbackConstName: "LOCALE_FALLBACK",
-      localeFallbackTypeName: "AppLocaleFallback",
-      paramsByNamespace: {
-        translations: {
-          welcome: "{ name: string }",
-        },
-      },
-      requestLocaleUnion: "'en' | 'it'",
-      hasLazy: false,
-      loadOnInitSet: new Set(),
-      lazyEntries: [],
-    });
-
-    expect(output).toContain(
-      "export type AppSchema = {\n  welcome: Partial<Record<AppLocale, string>>;\n};"
-    );
+    expect(output).toContain('export const AppLocales = ["en", "it"] as const;');
+    expect(output).toContain("export type AppLocale = (typeof AppLocales)[number];");
+    expect(output).toContain("export type LazyNamespace = 'default' | 'billing'");
+    expect(output).toContain("export type InitialSchema = Record<string, never>");
   });
 
   it("emits delivery area type for custom delivery", () => {
     const output = formatTypesFile({
-      isSingle: false,
       entries: [
         { namespace: "default", filePath: "src/i18n/translations/default.json" },
         { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
@@ -89,20 +65,23 @@ describe("formatTypesFile", () => {
         default: { some_key: "never" },
         billing: { invoice_summary: "{ count: number }" },
       },
-      requestLocaleUnion: "'en-US' | 'fr' | 'it'",
+      requestLocales: ["en-US", "fr", "it"],
       deliveryAreaTypeName: "AppDeliveryArea",
-      deliveryAreaUnion: "'eu' | 'us'",
+      deliveryAreaNames: ["eu", "us"],
       deliveryArtifacts: {
         eu: ["it", "fr"],
         us: ["en-US"],
       },
-      hasLazy: true,
-      loadOnInitSet: new Set(["default"]),
-      lazyEntries: [{ namespace: "billing", filePath: "src/i18n/translations/billing.yaml" }],
+      lazyEntries: [
+        { namespace: "default", filePath: "src/i18n/translations/default.json" },
+        { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
+      ],
     });
 
-    expect(output).toContain("export type AppLocale = 'en-US' | 'fr' | 'it';");
-    expect(output).toContain("export type AppDeliveryArea = 'eu' | 'us';");
+    expect(output).toContain('export const AppLocales = ["en-US", "fr", "it"] as const;');
+    expect(output).toContain("export type AppLocale = (typeof AppLocales)[number];");
+    expect(output).toContain('export const AppDeliveryAreas = ["eu", "us"] as const;');
+    expect(output).toContain("export type AppDeliveryArea = (typeof AppDeliveryAreas)[number];");
     expect(output).toContain("export const DELIVERY_ARTIFACTS = {");
     expect(output).toContain('"eu": ["fr", "it"] as const');
     expect(output).toContain('"us": ["en-US"] as const');