@xndrjs/i18n 0.8.0 → 0.8.2-alpha.0

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>>;");
-  });
-});

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

@@ -1,142 +0,0 @@
-import {
-  formatDeliveryArtifactsBlock,
-  formatLocaleDeliveryAreaBlock,
-  type DeliveryArtifactsMap,
-} from "../delivery-artifacts.js";
-import { formatLocaleFallbackBlock } from "../locale-fallback.js";
-import { GENERATED_FILE_BANNER } from "../paths.js";
-import type { NamespaceEntry } from "../types.js";
-
-/**
- * Emits lazy-load type aliases. Every namespace is lazy; `InitialSchema` is empty
- * (cold start / hydrate via `resources` only).
- */
-export function formatLazyTypesBlock(lazyEntries: NamespaceEntry[]): string {
-  const lazyUnion =
-    lazyEntries.length > 0
-      ? lazyEntries.map((entry) => `'${entry.namespace}'`).join(" | ")
-      : "never";
-
-  return (
-    `export type LazyNamespace = ${lazyUnion};\n` +
-    `/** Empty cold-start schema — namespaces arrive via \`namespaceLoaders\`. */\n` +
-    `export type InitialSchema = Record<string, never>;\n\n`
-  );
-}
-
-export function formatLocaleTemplateType(localeTypeName: string, hasLocaleUnion: boolean): string {
-  if (!hasLocaleUnion) {
-    return "Partial<Record<string, string>>";
-  }
-  return `Partial<Record<${localeTypeName}, string>>`;
-}
-
-export interface TypesFileOptions {
-  entries: NamespaceEntry[];
-  projectRoot: string;
-  typesOutputPath: string;
-  paramsTypeName: string;
-  schemaTypeName: string;
-  localeTypeName: string;
-  localeFallbackConstName: string;
-  localeFallbackTypeName: string;
-  localeFallback?: Record<string, string | null> | undefined;
-  paramsByNamespace: Record<string, Record<string, string>>;
-  /** Sorted request locales — emits `ProjectLocales` const + `ProjectLocale` type. */
-  requestLocales: readonly string[];
-  deliveryAreaTypeName?: string;
-  /** Sorted delivery area names — emits `ProjectDeliveryAreas` const + type. */
-  deliveryAreaNames?: readonly string[];
-  deliveryArtifacts?: DeliveryArtifactsMap;
-  localeDeliveryAreaConstName?: string;
-  lazyEntries: NamespaceEntry[];
-}
-
-export function formatTypesFile(options: TypesFileOptions): string {
-  const {
-    entries,
-    paramsTypeName,
-    schemaTypeName,
-    localeTypeName,
-    localeFallbackConstName,
-    localeFallbackTypeName,
-    localeFallback,
-    paramsByNamespace,
-    requestLocales,
-    deliveryAreaTypeName,
-    deliveryAreaNames,
-    deliveryArtifacts,
-    localeDeliveryAreaConstName = "LOCALE_DELIVERY_AREA",
-    lazyEntries,
-  } = options;
-
-  const hasLocaleUnion = requestLocales.length > 0;
-  const localeTemplateType = formatLocaleTemplateType(localeTypeName, hasLocaleUnion);
-  const localesConstName = `${localeTypeName}s`;
-
-  const localeBlock = hasLocaleUnion
-    ? `${localeFallback ? formatLocaleFallbackBlock(localeFallback, localeFallbackConstName, localeFallbackTypeName) : ""}` +
-      `export const ${localesConstName} = [${requestLocales.map((locale) => JSON.stringify(locale)).join(", ")}] as const;\n` +
-      `export type ${localeTypeName} = (typeof ${localesConstName})[number];\n\n`
-    : "";
-
-  const deliveryAreasConstName = deliveryAreaTypeName ? `${deliveryAreaTypeName}s` : undefined;
-  const deliveryAreaBlock =
-    deliveryAreaTypeName &&
-    deliveryAreasConstName &&
-    deliveryAreaNames &&
-    deliveryAreaNames.length > 0
-      ? `export const ${deliveryAreasConstName} = [${deliveryAreaNames.map((area) => JSON.stringify(area)).join(", ")}] as const;\n` +
-        `export type ${deliveryAreaTypeName} = (typeof ${deliveryAreasConstName})[number];\n\n` +
-        (deliveryArtifacts
-          ? formatDeliveryArtifactsBlock(
-              deliveryArtifacts,
-              "DELIVERY_ARTIFACTS",
-              localeTypeName,
-              deliveryAreaTypeName
-            ) +
-            formatLocaleDeliveryAreaBlock(
-              deliveryArtifacts,
-              localeDeliveryAreaConstName,
-              localeTypeName,
-              deliveryAreaTypeName
-            )
-          : "")
-      : "";
-
-  const namespaceBlocks = entries
-    .map((entry) => {
-      const keyTypes = paramsByNamespace[entry.namespace] ?? {};
-      const lines = Object.entries(keyTypes)
-        .map(([key, type]) => `    ${key}: ${type};`)
-        .join("\n");
-      return `  ${entry.namespace}: {\n${lines}\n  };`;
-    })
-    .join("\n");
-
-  const paramsBlock = `export type ${paramsTypeName} = {\n${namespaceBlocks}\n};`;
-
-  const schemaLines = entries
-    .map((entry) => {
-      const keyTypes = paramsByNamespace[entry.namespace] ?? {};
-      const lines = Object.keys(keyTypes)
-        .map((key) => `    ${key}: ${localeTemplateType};`)
-        .join("\n");
-      return `  ${entry.namespace}: {\n${lines}\n  };`;
-    })
-    .join("\n");
-
-  const schemaBlock = `export type ${schemaTypeName} = {\n${schemaLines}\n};`;
-
-  const lazyTypesBlock = formatLazyTypesBlock(lazyEntries);
-
-  return (
-    `${GENERATED_FILE_BANNER}` +
-    `export const I18N_MODE = 'multi' as const;\n\n` +
-    `${localeBlock}` +
-    `${deliveryAreaBlock}` +
-    `${paramsBlock}\n\n` +
-    `${schemaBlock}\n` +
-    `${lazyTypesBlock}`
-  );
-}

package/src/codegen/fixtures/billing-namespace.json

@@ -1,6 +0,0 @@
-{
-  "invoice_summary": {
-    "en": "You have {count, plural, one {1 invoice} other {{count} invoices}}",
-    "it": "Hai {count, plural, one {1 fattura} other {{count} fatture}}"
-  }
-}