@xndrjs/i18n 0.8.0 → 0.8.2-alpha.0

package/src/codegen/generate-i18n-types.ts

@@ -1,20 +0,0 @@
-/**
- * Codegen CLI entry point. Thin wrapper around {@link runCodegen}.
- */
-import path from "node:path";
-import { runCodegen } from "./run-codegen.js";
-
-function main() {
-  const configArgIndex = process.argv.indexOf("--config");
-  const configPath =
-    configArgIndex >= 0 ? process.argv[configArgIndex + 1]! : "i18n/i18n.codegen.json";
-
-  runCodegen(path.resolve(process.cwd(), configPath));
-}
-
-try {
-  main();
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-}

package/src/codegen/icu-analysis.ts

@@ -1,110 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { parse } from "@formatjs/icu-messageformat-parser";
-import {
-  extractVariableMeta,
-  mergeVariableMetaAcrossLocales,
-  type VariableSpec,
-} from "../icu/extract-variables.js";
-import type { DictionaryJson, NamespaceEntry } from "./types.js";
-import { readDictionaryFile } from "./read-dictionary.js";
-
-export function paramsTypeForVariables(variables: VariableSpec): string {
-  const keys = Object.keys(variables);
-  if (keys.length === 0) {
-    return "never";
-  }
-
-  const props = keys.map((key) => {
-    const type = variables[key] === "date" ? "Date | number" : variables[key];
-    return `${key}: ${type}`;
-  });
-  return `{ ${props.join("; ")} }`;
-}
-
-export interface DictionaryAnalysis {
-  paramsByNamespace: Record<string, Record<string, string>>;
-  argsSpecByNamespace: Record<string, Record<string, VariableSpec>>;
-  locales: Set<string>;
-  dictionariesByNamespace: Record<string, DictionaryJson>;
-}
-
-/**
- * Phase 1 of codegen: read source dictionaries, validate ICU syntax, infer param types.
- * Output feeds type emission, optional `DICTIONARY_SPEC`, and `prepareDictionaryEntries`.
- */
-export function analyzeDictionaries(
-  projectRoot: string,
-  entries: NamespaceEntry[]
-): { ok: true; analysis: DictionaryAnalysis } | { ok: false } {
-  const paramsByNamespace: Record<string, Record<string, string>> = {};
-  const argsSpecByNamespace: Record<string, Record<string, VariableSpec>> = {};
-  const locales = new Set<string>();
-  const dictionariesByNamespace: Record<string, DictionaryJson> = {};
-  let hasErrors = false;
-
-  for (const entry of entries) {
-    const absolutePath = path.resolve(projectRoot, entry.filePath);
-
-    if (!fs.existsSync(absolutePath)) {
-      console.error(
-        `[Codegen Error] Dictionary file not found for namespace "${entry.namespace}": ${absolutePath}`
-      );
-      hasErrors = true;
-      continue;
-    }
-
-    const dictionary = readDictionaryFile(absolutePath);
-    dictionariesByNamespace[entry.namespace] = dictionary;
-    paramsByNamespace[entry.namespace] = {};
-    argsSpecByNamespace[entry.namespace] = {};
-
-    for (const [key, localesByKey] of Object.entries(dictionary)) {
-      const localeMetas: ReturnType<typeof extractVariableMeta>[] = [];
-
-      for (const locale of Object.keys(localesByKey)) {
-        locales.add(locale);
-      }
-
-      for (const [locale, template] of Object.entries(localesByKey)) {
-        try {
-          const ast = parse(template);
-          localeMetas.push(extractVariableMeta(ast));
-        } catch (error) {
-          hasErrors = true;
-          const message = error instanceof Error ? error.message : String(error);
-          console.error(
-            `[Codegen Error] ICU syntax error — namespace "${entry.namespace}", key "${key}", locale "${locale}": ${message}`
-          );
-        }
-      }
-
-      if (localeMetas.length === 0) {
-        continue;
-      }
-
-      const mergedVariables = mergeVariableMetaAcrossLocales(localeMetas);
-      if (!mergedVariables.ok) {
-        hasErrors = true;
-        console.error(
-          `[Codegen Error] ${mergedVariables.message} — namespace "${entry.namespace}", key "${key}"`
-        );
-        continue;
-      }
-
-      const variables = mergedVariables.merged;
-
-      paramsByNamespace[entry.namespace]![key] = paramsTypeForVariables(variables);
-      argsSpecByNamespace[entry.namespace]![key] = variables;
-    }
-  }
-
-  if (hasErrors) {
-    return { ok: false };
-  }
-
-  return {
-    ok: true,
-    analysis: { paramsByNamespace, argsSpecByNamespace, locales, dictionariesByNamespace },
-  };
-}

package/src/codegen/locale-fallback.ts

@@ -1,73 +0,0 @@
-import { validateLocaleFallback } from "../resolve-locale.js";
-
-/**
- * Union of locales found in dictionaries plus every locale referenced by `localeFallback`.
- * Drives split-by-locale partitioning and the generated locale union type.
- */
-export function collectRequestLocales(
-  dictionaryLocales: Set<string>,
-  fallback?: Record<string, string | null>
-): Set<string> {
-  const all = new Set(dictionaryLocales);
-  if (!fallback) {
-    return all;
-  }
-
-  for (const [locale, target] of Object.entries(fallback)) {
-    all.add(locale);
-    if (target !== null) {
-      all.add(target);
-    }
-  }
-
-  return all;
-}
-
-export type LocaleFallbackIssue = {
-  path: (string | number)[];
-  message: string;
-};
-
-/** Pre-emit validation gate for `localeFallback` config against discovered dictionary locales. */
-export function getCodegenLocaleFallbackIssues(
-  fallback: Record<string, string | null>,
-  dictionaryLocales: Set<string>
-): LocaleFallbackIssue[] {
-  const issues: LocaleFallbackIssue[] = [];
-
-  try {
-    validateLocaleFallback(fallback);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    issues.push({ path: ["localeFallback"], message });
-  }
-
-  for (const [locale, target] of Object.entries(fallback)) {
-    if (target !== null && !(target in fallback) && !dictionaryLocales.has(target)) {
-      issues.push({
-        path: ["localeFallback", locale],
-        message: `localeFallback: "${locale}" points to "${target}" which is not defined in the fallback map or dictionary locales`,
-      });
-    }
-  }
-
-  return issues;
-}
-
-export function formatLocaleFallbackBlock(
-  fallback: Record<string, string | null>,
-  constName: string,
-  typeName: string
-): string {
-  const lines = Object.entries(fallback)
-    .map(
-      ([locale, target]) =>
-        `  ${JSON.stringify(locale)}: ${target === null ? "null" : JSON.stringify(target)},`
-    )
-    .join("\n");
-
-  return (
-    `export const ${constName} = {\n${lines}\n} as const satisfies Record<string, string | null>;\n\n` +
-    `export type ${typeName} = typeof ${constName};\n\n`
-  );
-}

package/src/codegen/locale-policy.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildRequiredLocales, enrichLocaleFallback } from "./locale-policy.js";
-
-describe("locale-policy", () => {
-  it("buildRequiredLocales unions dictionary locales with fallback keys and targets", () => {
-    const locales = new Set(["en", "it"]);
-    const fallback = { en: null, "de-CH": "de-DE", "de-DE": "en", it: "en" };
-
-    expect(buildRequiredLocales(locales, fallback)).toEqual(["de-CH", "de-DE", "en", "it"]);
-    expect(buildRequiredLocales(locales)).toEqual(["en", "it"]);
-  });
-
-  it("enrichLocaleFallback adds null for required locales missing from config", () => {
-    const locales = new Set(["en", "fr"]);
-    const fallback = { en: null, it: "en" };
-
-    expect(enrichLocaleFallback(locales, fallback)).toEqual({
-      en: null,
-      fr: null,
-      it: "en",
-    });
-  });
-
-  it("enrichLocaleFallback is a no-op when all required locales are already configured", () => {
-    const locales = new Set(["en", "it"]);
-    const fallback = {
-      en: null,
-      "de-DE": "en",
-      "de-CH": "de-DE",
-      it: "en",
-    };
-
-    expect(enrichLocaleFallback(locales, fallback)).toEqual(fallback);
-  });
-});

package/src/codegen/locale-policy.ts

@@ -1,30 +0,0 @@
-import { collectRequestLocales } from "./locale-fallback.js";
-
-export function buildRequiredLocales(
-  dictionaryLocales: Set<string>,
-  configFallback?: Record<string, string | null>
-): string[] {
-  return [...collectRequestLocales(dictionaryLocales, configFallback)].sort();
-}
-
-/**
- * Completes `localeFallback` with explicit `null` entries for every request locale,
- * producing a stable map emitted into `i18n-types.generated.ts`.
- */
-export function enrichLocaleFallback(
-  dictionaryLocales: Set<string>,
-  configFallback: Record<string, string | null>
-): Record<string, string | null> {
-  const enriched: Record<string, string | null> = { ...configFallback };
-
-  for (const locale of buildRequiredLocales(dictionaryLocales, configFallback)) {
-    if (!(locale in enriched)) {
-      enriched[locale] = null;
-    }
-  }
-
-  const sortedEntries = Object.entries(enriched).sort(([left], [right]) =>
-    left.localeCompare(right)
-  );
-  return Object.fromEntries(sortedEntries);
-}

package/src/codegen/paths.ts

@@ -1,44 +0,0 @@
-import path from "node:path";
-import type { ImportExtension } from "./types.js";
-
-export const GENERATED_FILE_BANNER = "// Automatically generated code. Do not edit manually.\n";
-export const DEFAULT_IMPORT_EXTENSION: ImportExtension = "none";
-
-export function reportCodegenIssues(issues: readonly { message: string }[]): void {
-  for (const issue of issues) {
-    console.error(`[Codegen Error] ${issue.message}`);
-  }
-}
-
-export function toImportPath(fromFile: string, toFile: string): string {
-  const relative = path.relative(path.dirname(fromFile), toFile).replace(/\\/g, "/");
-  const withoutExt = relative.replace(/\.(json|ya?ml)$/i, "");
-  return withoutExt.startsWith(".") ? withoutExt : `./${withoutExt}`;
-}
-
-export function toModuleBasename(filePath: string): string {
-  return path.basename(filePath).replace(/\.ts$/, "");
-}
-
-export function importExtensionSuffix(importExtension: ImportExtension): string {
-  return importExtension === "none" ? "" : importExtension;
-}
-
-export function toRelativeModuleImport(
-  moduleBasename: string,
-  importExtension: ImportExtension
-): string {
-  return `./${moduleBasename}${importExtensionSuffix(importExtension)}`;
-}
-
-export function toImportIdentifier(namespace: string): string {
-  const safe = namespace.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[0-9]/.test(safe)) {
-    return `ns_${safe}`;
-  }
-  return `${safe}Ns`;
-}
-
-export function toLocaleObjectKey(locale: string): string {
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(locale) ? locale : JSON.stringify(locale);
-}

package/src/codegen/project-locales-set-namespace.test.ts

@@ -1,134 +0,0 @@
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { afterEach, describe, expect, it } from "vitest";
-
-const codegenScript = fileURLToPath(new URL("./generate-i18n-types.ts", import.meta.url));
-const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
-
-function runCodegen(cwd: string) {
-  return spawnSync("tsx", [codegenScript, "--config", "i18n.codegen.json"], {
-    cwd,
-    encoding: "utf8",
-    env: process.env,
-  });
-}
-
-function runTsc(projectPath: string) {
-  return spawnSync("pnpm", ["exec", "tsc", "--noEmit", "-p", projectPath], {
-    cwd: packageRoot,
-    encoding: "utf8",
-    env: process.env,
-  });
-}
-
-function setupMultiCodegenFixture(tempDir: string) {
-  const i18nDir = join(tempDir, "src/i18n");
-  const translationsDir = join(i18nDir, "translations");
-  mkdirSync(translationsDir, { recursive: true });
-
-  writeFileSync(
-    join(translationsDir, "default.json"),
-    JSON.stringify({
-      login_button: { en: "Login" },
-    })
-  );
-  writeFileSync(
-    join(translationsDir, "billing.json"),
-    readFileSync(
-      fileURLToPath(new URL("./fixtures/billing-namespace.json", import.meta.url)),
-      "utf8"
-    )
-  );
-
-  writeFileSync(
-    join(tempDir, "i18n.codegen.json"),
-    JSON.stringify({
-      projectName: "App",
-      namespaces: {
-        default: "src/i18n/translations/default.json",
-        billing: "src/i18n/translations/billing.json",
-      },
-      codegenPath: "src/i18n",
-      localeFallback: {
-        en: null,
-        it: "en",
-      },
-    })
-  );
-
-  const codegen = runCodegen(tempDir);
-  expect(codegen.status, codegen.stderr || codegen.stdout).toBe(0);
-}
-
-function writeTscProject(tempDir: string) {
-  writeFileSync(
-    join(tempDir, "tsconfig.json"),
-    JSON.stringify(
-      {
-        compilerOptions: {
-          target: "ES2022",
-          module: "ESNext",
-          moduleResolution: "bundler",
-          strict: true,
-          noEmit: true,
-          resolveJsonModule: true,
-          esModuleInterop: true,
-          skipLibCheck: true,
-          paths: {
-            "@xndrjs/i18n": [join(packageRoot, "src/index.ts")],
-            "@xndrjs/i18n/validation": [join(packageRoot, "src/validation/index.ts")],
-          },
-        },
-        include: ["src/**/*.ts"],
-      },
-      null,
-      2
-    )
-  );
-}
-
-describe("codegen instance + load", () => {
-  let tempDir: string;
-
-  afterEach(() => {
-    if (tempDir) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it("emits createI18n wired to namespaceLoaders", () => {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-project-locales-"));
-    setupMultiCodegenFixture(tempDir);
-
-    const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
-    expect(factory).toContain("export function createI18n(");
-    expect(factory).toContain("namespaceLoaders");
-  });
-
-  it("passes tsc when loading via generated namespaceLoaders", () => {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-project-locales-"));
-    setupMultiCodegenFixture(tempDir);
-
-    writeFileSync(
-      join(tempDir, "src/hydrate-billing.ts"),
-      [
-        `import { createI18n } from "./i18n/instance.generated.js";`,
-        ``,
-        `async function hydrateBilling() {`,
-        `  const { t } = await createI18n().load({ namespaces: ["billing"], locale: "en" });`,
-        `  return t("billing", "invoice_summary", { count: 1 });`,
-        `}`,
-        ``,
-        `export { hydrateBilling };`,
-      ].join("\n")
-    );
-
-    writeTscProject(tempDir);
-
-    const tsc = runTsc(join(tempDir, "tsconfig.json"));
-    expect(tsc.status, `${tsc.stdout}\n${tsc.stderr}`).toBe(0);
-  });
-});