@xndrjs/i18n 0.8.1 → 0.8.2-alpha.1

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

@@ -1,251 +0,0 @@
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { formatNamespaceLoadersFile } from "./namespace-loaders-file.js";
-
-const projectRoot = "/project";
-const loadersOutputPath = path.join(projectRoot, "src/i18n/namespace-loaders.generated.ts");
-
-describe("formatNamespaceLoadersFile", () => {
-  it("emits ns(locale) loaders in split mode", () => {
-    const output = formatNamespaceLoadersFile({
-      loadersOutputPath,
-      lazyEntries: [
-        {
-          namespace: "billing",
-          filePath: "src/i18n/translations/billing.json",
-          absolutePath: path.join(projectRoot, "src/i18n/translations/billing.json"),
-        },
-        {
-          namespace: "default",
-          filePath: "src/i18n/translations/default.json",
-          absolutePath: path.join(projectRoot, "src/i18n/translations/default.json"),
-        },
-        {
-          namespace: "user",
-          filePath: "src/i18n/translations/user.json",
-          absolutePath: path.join(projectRoot, "src/i18n/translations/user.json"),
-        },
-      ],
-      schemaTypeName: "AppSchema",
-      localeTypeName: "AppLocale",
-      typesModule: "i18n-types.generated",
-      importExtension: "none",
-      projectRoot,
-      delivery: "split-by-locale",
-      requestLocales: ["en", "it", "de-CH"],
-      splitPathsByNamespace: {
-        billing: {
-          en: "src/i18n/generated/translations/billing.en.json",
-          it: "src/i18n/generated/translations/billing.it.json",
-          "de-CH": "src/i18n/generated/translations/billing.de-CH.json",
-        },
-        default: {
-          en: "src/i18n/generated/translations/default.en.json",
-          it: "src/i18n/generated/translations/default.it.json",
-          "de-CH": "src/i18n/generated/translations/default.de-CH.json",
-        },
-        user: {
-          en: "src/i18n/generated/translations/user.en.json",
-          it: "src/i18n/generated/translations/user.it.json",
-          "de-CH": "src/i18n/generated/translations/user.de-CH.json",
-        },
-      },
-    });
-
-    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":');
-    expect(output).toContain('case "it":');
-    expect(output).toContain('case "de-CH":');
-    expect(output).toContain(
-      'throw new Error(`[i18n] No translation artifact for namespace "billing" and locale "${String(locale)}".`);'
-    );
-    expect(output).toContain(
-      "return import('./generated/translations/billing.en.json').then((m) => m.default);"
-    );
-    expect(output).toContain("user: (locale) => {");
-    expect(output).toContain(
-      'export const defaultLazyNamespaces = ["billing", "default", "user"] as const;'
-    );
-    expect(output.match(/from '\.\/i18n-types\.generated'/g)?.length).toBe(1);
-  });
-
-  it("throws when a split path is missing", () => {
-    expect(() =>
-      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"],
-        splitPathsByNamespace: {
-          billing: {
-            en: "src/i18n/generated/translations/billing.en.json",
-          },
-        },
-      })
-    ).toThrow('[Codegen Error] Missing split path for namespace "billing", locale "it".');
-  });
-
-  it("emits ns(area) loaders in custom mode", () => {
-    const output = formatNamespaceLoadersFile({
-      loadersOutputPath,
-      lazyEntries: [
-        {
-          namespace: "billing",
-          filePath: "src/i18n/translations/billing.json",
-          absolutePath: path.join(projectRoot, "src/i18n/translations/billing.json"),
-        },
-        {
-          namespace: "default",
-          filePath: "src/i18n/translations/default.json",
-          absolutePath: path.join(projectRoot, "src/i18n/translations/default.json"),
-        },
-      ],
-      schemaTypeName: "AppSchema",
-      localeTypeName: "AppLocale",
-      typesModule: "i18n-types.generated",
-      importExtension: "none",
-      projectRoot,
-      delivery: "custom",
-      deliveryAreaTypeName: "AppDeliveryArea",
-      deliveryAreaNames: ["eu", "us"],
-      splitPathsByNamespace: {
-        billing: {
-          eu: "src/i18n/generated/translations/billing.eu.json",
-          us: "src/i18n/generated/translations/billing.us.json",
-        },
-        default: {
-          eu: "src/i18n/generated/translations/default.eu.json",
-          us: "src/i18n/generated/translations/default.us.json",
-        },
-      },
-    });
-
-    expect(output).toContain(
-      "import type { AppSchema, LazyNamespace, AppDeliveryArea } from './i18n-types.generated';"
-    );
-    expect(output).toContain(
-      "[K in LazyNamespace]: (area: AppDeliveryArea) => Promise<AppSchema[K]>;"
-    );
-    expect(output).toContain("billing: (area) => {");
-    expect(output).toContain('case "eu":');
-    expect(output).toContain('case "us":');
-    expect(output).toContain(
-      'throw new Error(`[i18n] No translation artifact for namespace "billing" and area "${String(area)}".`);'
-    );
-    expect(output).toContain(
-      "return import('./generated/translations/billing.eu.json').then((m) => m.default);"
-    );
-    expect(output).toContain(
-      'export const defaultLazyNamespaces = ["billing", "default"] as const;'
-    );
-  });
-
-  it("throws when a custom delivery split path is missing", () => {
-    expect(() =>
-      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"],
-        splitPathsByNamespace: {
-          billing: {
-            eu: "src/i18n/generated/translations/billing.eu.json",
-          },
-        },
-      })
-    ).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,229 +0,0 @@
-import path from "node:path";
-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()`
- * or injectable `fetchImpl(resourceId)` loaders, shaped by delivery mode.
- */
-export interface NamespaceLoadersFileOptions {
-  loadersOutputPath: string;
-  lazyEntries: (NamespaceEntry & { absolutePath: string })[];
-  schemaTypeName: string;
-  localeTypeName: string;
-  typesModule: string;
-  importExtension: ImportExtension;
-  projectRoot: string;
-  delivery: DeliveryMode;
-  splitPathsByNamespace?: Record<string, Record<string, string>>;
-  requestLocales?: readonly string[];
-  deliveryAreaTypeName?: string;
-  deliveryAreaNames?: readonly string[];
-  loaderStrategy?: LoaderStrategy;
-}
-
-interface PartitionedNamespaceLoadersParams {
-  partitionKeys: readonly string[];
-  paramName: string;
-  paramTypeName: string;
-}
-
-function formatDefaultNamespacesLiteral(lazyEntries: NamespaceEntry[]): string {
-  return [...lazyEntries]
-    .map((entry) => entry.namespace)
-    .sort()
-    .map((namespace) => JSON.stringify(namespace))
-    .join(", ");
-}
-
-function formatPartitionedTypesImport(
-  options: NamespaceLoadersFileOptions,
-  paramTypeName: string
-): string {
-  const { schemaTypeName, typesModule, importExtension } = options;
-  return `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName} } 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);`;
-}
-
-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 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
-  );
-}
-
-function formatPartitionedNamespaceLoadersFile(
-  options: NamespaceLoadersFileOptions,
-  params: PartitionedNamespaceLoadersParams
-): string {
-  const { partitionKeys, paramName, paramTypeName } = params;
-  const {
-    loadersOutputPath,
-    lazyEntries,
-    schemaTypeName,
-    projectRoot,
-    delivery,
-    splitPathsByNamespace = {},
-  } = options;
-  const loaderStrategy = options.loaderStrategy ?? "import";
-
-  const loaderValueType = `${schemaTypeName}[K]`;
-  const typesImport = formatPartitionedTypesImport(options, paramTypeName);
-
-  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 (
-      `${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`
-    );
-  }
-
-  const loaderEntries = lazyEntries
-    .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}` +
-    typesImport +
-    `export const namespaceLoaders: ${importLoadersType} = {\n${loaderEntries}\n};\n` +
-    `\n` +
-    `export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;\n`
-  );
-}
-
-/**
- * Builds `namespace-loaders.generated.ts` for split-by-locale or custom delivery areas.
- */
-export function formatNamespaceLoadersFile(options: NamespaceLoadersFileOptions): string {
-  if (options.delivery === "split-by-locale") {
-    return formatPartitionedNamespaceLoadersFile(options, {
-      partitionKeys: options.requestLocales ?? [],
-      paramName: "locale",
-      paramTypeName: options.localeTypeName,
-    });
-  }
-  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,
-  });
-}

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

@@ -1,96 +0,0 @@
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { formatTypesFile } from "./types-file.js";
-
-const projectRoot = "/project";
-const typesOutputPath = path.join(projectRoot, "src/i18n/generated/i18n-types.generated.ts");
-
-describe("formatTypesFile", () => {
-  it("emits explicit Partial schema types and lazy aliases", () => {
-    const output = formatTypesFile({
-      entries: [
-        { namespace: "default", filePath: "src/i18n/translations/default.json" },
-        { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
-      ],
-      projectRoot,
-      typesOutputPath,
-      paramsTypeName: "AppParams",
-      schemaTypeName: "AppSchema",
-      localeTypeName: "AppLocale",
-      localeFallbackConstName: "LOCALE_FALLBACK",
-      localeFallbackTypeName: "AppLocaleFallback",
-      paramsByNamespace: {
-        default: {
-          login_button: "never",
-          welcome: "{ name: string }",
-        },
-        billing: {
-          invoice_summary: "{ count: number }",
-        },
-      },
-      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>>;");
-    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({
-      entries: [
-        { namespace: "default", filePath: "src/i18n/translations/default.json" },
-        { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
-      ],
-      projectRoot,
-      typesOutputPath,
-      paramsTypeName: "AppParams",
-      schemaTypeName: "AppSchema",
-      localeTypeName: "AppLocale",
-      localeFallbackConstName: "LOCALE_FALLBACK",
-      localeFallbackTypeName: "AppLocaleFallback",
-      localeFallback: {
-        "en-US": null,
-        it: "en-US",
-        fr: null,
-      },
-      paramsByNamespace: {
-        default: { some_key: "never" },
-        billing: { invoice_summary: "{ count: number }" },
-      },
-      requestLocales: ["en-US", "fr", "it"],
-      deliveryAreaTypeName: "AppDeliveryArea",
-      deliveryAreaNames: ["eu", "us"],
-      deliveryArtifacts: {
-        eu: ["it", "fr"],
-        us: ["en-US"],
-      },
-      lazyEntries: [
-        { namespace: "default", filePath: "src/i18n/translations/default.json" },
-        { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
-      ],
-    });
-
-    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');
-    expect(output).toContain("} as const satisfies Record<AppDeliveryArea, readonly AppLocale[]>;");
-    expect(output).toContain("export type AppDeliveryArtifacts = typeof DELIVERY_ARTIFACTS;");
-    expect(output).toContain("export const LOCALE_DELIVERY_AREA = {");
-    expect(output).toContain('"it": "eu"');
-    expect(output).toContain('"en-US": "us"');
-    expect(output).toContain("} as const satisfies Record<AppLocale, AppDeliveryArea>;");
-    expect(output).toContain("some_key: Partial<Record<AppLocale, string>>;");
-  });
-});