@xndrjs/i18n 0.2.0-alpha.0

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

@@ -0,0 +1,482 @@
+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 { describe, expect, it, afterEach } from "vitest";
+
+const codegenScript = fileURLToPath(new URL("./generate-i18n-types.ts", import.meta.url));
+
+function runCodegen(cwd: string, configFile = "i18n.codegen.json") {
+  return spawnSync("tsx", [codegenScript, "--config", configFile], {
+    cwd,
+    encoding: "utf8",
+    env: process.env,
+  });
+}
+
+describe("generate-i18n-types", () => {
+  let tempDir: string;
+
+  afterEach(() => {
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it("generates nested types for multi-namespace config", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/default.json"),
+      JSON.stringify({
+        login_button: { en: "Login" },
+        welcome: { en: "Welcome {name}!" },
+        inbox_owner: {
+          en: "{gender, select, female {{name} owns her inbox} other {{name} owns their inbox}}",
+        },
+        account_balance: { en: "Balance: {amount, number, ::currency/EUR}" },
+        appointment_summary: {
+          en: "Due {dueDate, date, short} at {startTime, time, short}",
+        },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/billing.json"),
+      JSON.stringify({
+        invoice_summary: {
+          en: "You have {count, plural, one {1 invoice} other {{count} invoices}}",
+        },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        namespaces: {
+          default: "src/i18n/translations/default.json",
+          billing: "src/i18n/translations/billing.json",
+        },
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const types = readFileSync(join(tempDir, "src/i18n/i18n-types.generated.ts"), "utf8");
+    const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
+    expect(types).toContain("export const I18N_MODE = 'multi' as const");
+    expect(types).toContain("export type AppLocale = 'en'");
+    expect(factory).toContain("export function createI18n(");
+    expect(factory).toContain("IcuTranslationProviderMulti");
+    expect(types).toContain("login_button: never");
+    expect(types).toContain("welcome: { name: string }");
+    expect(types).toContain("inbox_owner: { gender: string; name: string }");
+    expect(types).toContain("account_balance: { amount: number }");
+    expect(types).toContain(
+      "appointment_summary: { dueDate: Date | number; startTime: Date | number }"
+    );
+    expect(types).toContain("invoice_summary: { count: number }");
+    expect(types).toContain("export type AppParams");
+    expect(types).toContain("export type AppSchema");
+  });
+
+  it("generates dictionary schema file when dictionarySchemaOutput is set", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/default.json"),
+      JSON.stringify({
+        welcome: { en: "Welcome {name}!" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/billing.json"),
+      JSON.stringify({
+        invoice_summary: {
+          en: "You have {count, plural, one {1 invoice} other {{count} invoices}}",
+        },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        namespaces: {
+          default: "src/i18n/translations/default.json",
+          billing: "src/i18n/translations/billing.json",
+        },
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        dictionarySchemaOutput: "src/i18n/dictionary-schema.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const schema = readFileSync(join(tempDir, "src/i18n/dictionary-schema.generated.ts"), "utf8");
+    expect(schema).toContain("export const DICTIONARY_SPEC");
+    expect(schema).toContain("mode: 'multi' as const");
+    expect(schema).toContain("validateExternalDictionary");
+    expect(schema).toContain("validateExternalNamespace");
+    expect(schema).toContain('"name": "string"');
+  });
+
+  it("does not generate dictionary schema file when dictionarySchemaOutput is omitted", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/translations.json"),
+      JSON.stringify({
+        login_button: { en: "Login" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        dictionary: "src/i18n/translations/translations.json",
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+    expect(result.stdout).not.toContain("dictionary-schema.generated.ts");
+  });
+
+  it("generates single-mode dictionary schema without namespace validator", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/translations.json"),
+      JSON.stringify({
+        welcome: { en: "Welcome {name}!" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        dictionary: "src/i18n/translations/translations.json",
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        dictionarySchemaOutput: "src/i18n/dictionary-schema.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const schema = readFileSync(join(tempDir, "src/i18n/dictionary-schema.generated.ts"), "utf8");
+    expect(schema).toContain("mode: 'single' as const");
+    expect(schema).toContain("validateExternalDictionary");
+    expect(schema).not.toContain("validateExternalNamespaceImpl");
+  });
+
+  it("generates flat types for single-file config", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/translations.json"),
+      JSON.stringify({
+        login_button: { en: "Login" },
+        welcome: { en: "Welcome {name}!" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        dictionary: "src/i18n/translations/translations.json",
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const types = readFileSync(join(tempDir, "src/i18n/i18n-types.generated.ts"), "utf8");
+    const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
+    expect(types).toContain("export const I18N_MODE = 'single' as const");
+    expect(types).toContain("export type AppLocale = 'en'");
+    expect(factory).toContain("export function createI18n(");
+    expect(factory).toContain("IcuTranslationProviderSingle");
+    expect(types).toContain("login_button: never;");
+    expect(types).toContain("welcome: { name: string };");
+    expect(types).not.toContain("default: {");
+  });
+
+  it("fails with a non-zero exit code on malformed ICU", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/translations.json"),
+      JSON.stringify({
+        broken: { en: "Hello {{name}}" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        dictionary: "src/i18n/translations/translations.json",
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain("MALFORMED_ARGUMENT");
+  });
+
+  it("generates locale fallback constants and wires them into the factory", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/translations.json"),
+      JSON.stringify({
+        login_button: { en: "Login" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        dictionary: "src/i18n/translations/translations.json",
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+        localeFallback: {
+          en: null,
+          "de-CH": "en",
+        },
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const types = readFileSync(join(tempDir, "src/i18n/i18n-types.generated.ts"), "utf8");
+    const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
+    expect(types).toContain("export const LOCALE_FALLBACK");
+    expect(types).toContain('"de-CH": "en"');
+    expect(types).toContain("export type AppLocale = 'de-CH' | 'en'");
+    expect(factory).toContain("localeFallback: LOCALE_FALLBACK");
+    expect(factory).toContain(
+      "IcuTranslationProviderSingle<AppSchema, AppParams, AppLocale, typeof LOCALE_FALLBACK>"
+    );
+  });
+
+  it("fails on circular locale fallback in config", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/translations.json"),
+      JSON.stringify({
+        login_button: { en: "Login" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        dictionary: "src/i18n/translations/translations.json",
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+        localeFallback: {
+          a: "b",
+          b: "a",
+        },
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain("Circular locale fallback");
+  });
+
+  it("generates lazy namespace loaders when loadOnInit is a subset", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/default.json"),
+      JSON.stringify({
+        welcome: { en: "Welcome {name}!" },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/billing.json"),
+      JSON.stringify({
+        invoice_summary: {
+          en: "You have {count, plural, one {1 invoice} other {{count} invoices}}",
+        },
+      })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        namespaces: {
+          default: "src/i18n/translations/default.json",
+          billing: "src/i18n/translations/billing.json",
+        },
+        loadOnInit: ["default"],
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        dictionarySchemaOutput: "src/i18n/dictionary-schema.generated.ts",
+        namespaceLoadersOutput: "src/i18n/namespace-loaders.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const types = readFileSync(join(tempDir, "src/i18n/i18n-types.generated.ts"), "utf8");
+    const dictionary = readFileSync(join(tempDir, "src/i18n/dictionary.generated.ts"), "utf8");
+    const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
+    const loaders = readFileSync(join(tempDir, "src/i18n/namespace-loaders.generated.ts"), "utf8");
+
+    expect(types).toContain("export type LoadOnInitNamespace = 'default'");
+    expect(types).toContain("export type LazyNamespace = 'billing'");
+    expect(types).toContain("export type InitialSchema = Pick<AppSchema, LoadOnInitNamespace>");
+    expect(dictionary).toContain("export const dictionary: InitialSchema");
+    expect(dictionary).not.toContain("billingNs");
+    expect(factory).toContain("initialDictionary: InitialSchema = dictionary");
+    expect(loaders).toContain("export const namespaceLoaders");
+    expect(loaders).toContain("export async function ensureNamespacesLoaded(");
+    expect(loaders).toContain("namespaces: LazyNamespace[]");
+    expect(loaders).toContain("import('./translations/billing.json')");
+  });
+
+  it("keeps eager output when loadOnInit is omitted", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/default.json"),
+      JSON.stringify({ welcome: { en: "Welcome {name}!" } })
+    );
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/billing.json"),
+      JSON.stringify({ invoice_summary: { en: "Invoice" } })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        namespaces: {
+          default: "src/i18n/translations/default.json",
+          billing: "src/i18n/translations/billing.json",
+        },
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const types = readFileSync(join(tempDir, "src/i18n/i18n-types.generated.ts"), "utf8");
+    const dictionary = readFileSync(join(tempDir, "src/i18n/dictionary.generated.ts"), "utf8");
+    const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
+
+    expect(types).not.toContain("LazyNamespace");
+    expect(dictionary).toContain("export const dictionary: AppSchema");
+    expect(dictionary).toContain("billingNs");
+    expect(factory).toContain("initialDictionary: AppSchema = dictionary");
+    expect(result.stdout).not.toContain("namespace-loaders.generated.ts");
+  });
+
+  it("fails when loadOnInit is used in single mode", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/translations.json"),
+      JSON.stringify({ welcome: { en: "Welcome" } })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        dictionary: "src/i18n/translations/translations.json",
+        loadOnInit: ["default"],
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain("loadOnInit");
+  });
+
+  it("keeps multi mode when namespaces has a single entry", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-codegen-"));
+    mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
+
+    writeFileSync(
+      join(tempDir, "src/i18n/translations/default.json"),
+      JSON.stringify({ welcome: { en: "Welcome {name}!" } })
+    );
+    writeFileSync(
+      join(tempDir, "i18n.codegen.json"),
+      JSON.stringify({
+        namespaces: {
+          default: "src/i18n/translations/default.json",
+        },
+        typesOutput: "src/i18n/i18n-types.generated.ts",
+        dictionaryOutput: "src/i18n/dictionary.generated.ts",
+        instanceOutput: "src/i18n/instance.generated.ts",
+        paramsTypeName: "AppParams",
+        schemaTypeName: "AppSchema",
+      })
+    );
+
+    const result = runCodegen(tempDir);
+    expect(result.status).toBe(0);
+
+    const types = readFileSync(join(tempDir, "src/i18n/i18n-types.generated.ts"), "utf8");
+    const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
+    expect(types).toContain("export const I18N_MODE = 'multi' as const");
+    expect(types).toContain("default: {");
+    expect(factory).toContain("IcuTranslationProviderMulti");
+  });
+});

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

@@ -0,0 +1,173 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig, resolveLoadOnInit, resolveNamespaces } from "./config.js";
+import { formatDictionaryFile } from "./emit/dictionary-file.js";
+import {
+  formatDictionarySchemaFile,
+  formatDictionarySpecBlock,
+} from "./emit/dictionary-schema-file.js";
+import { formatInstanceFile } from "./emit/instance-file.js";
+import { formatNamespaceLoadersFile } from "./emit/namespace-loaders-file.js";
+import { formatTypesFile } from "./emit/types-file.js";
+import { analyzeDictionaries } from "./icu-analysis.js";
+import { collectRequestLocales, validateCodegenLocaleFallback } from "./locale-fallback.js";
+import { fail, toModuleBasename } from "./paths.js";
+
+function main() {
+  const configArgIndex = process.argv.indexOf("--config");
+  const configPath = path.resolve(
+    process.cwd(),
+    configArgIndex >= 0 ? process.argv[configArgIndex + 1]! : "i18n.codegen.json"
+  );
+  const projectRoot = path.dirname(configPath);
+
+  if (!fs.existsSync(configPath)) {
+    fail(`[Codegen Error] Config file not found: ${configPath}`);
+  }
+
+  const config = loadConfig(configPath);
+  const entries = resolveNamespaces(config);
+  const isSingle = Boolean(config.dictionary);
+  const { loadOnInitSet, lazyEntries, hasLazy } = resolveLoadOnInit(config, entries, isSingle);
+
+  if (hasLazy && !config.dictionarySchemaOutput) {
+    fail(
+      '[Codegen Error] Lazy namespaces require "dictionarySchemaOutput" for validateExternalNamespace.'
+    );
+  }
+
+  const typesOutputPath = path.resolve(projectRoot, config.typesOutput);
+  const dictionaryOutputPath = path.resolve(projectRoot, config.dictionaryOutput);
+  const instanceOutputPath = path.resolve(projectRoot, config.instanceOutput);
+
+  const analysisResult = analyzeDictionaries(projectRoot, entries);
+  if (!analysisResult.ok) {
+    process.exit(1);
+  }
+
+  const { paramsByNamespace, argsSpecByNamespace, locales } = analysisResult.analysis;
+
+  if (config.localeFallback && validateCodegenLocaleFallback(config.localeFallback, locales)) {
+    process.exit(1);
+  }
+
+  const paramsTypeName = config.paramsTypeName;
+  const schemaTypeName = config.schemaTypeName;
+  const localeTypeName = config.localeTypeName ?? schemaTypeName.replace(/Schema$/, "Locale");
+  const localeFallbackConstName = config.localeFallbackConstName ?? "LOCALE_FALLBACK";
+  const localeFallbackTypeName = `${localeTypeName}Fallback`;
+  const factoryName = config.factoryName ?? "createI18n";
+  const typesModule = toModuleBasename(typesOutputPath);
+
+  const requestLocales = collectRequestLocales(locales, config.localeFallback);
+  const requestLocaleUnion = [...requestLocales]
+    .sort()
+    .map((locale) => `'${locale}'`)
+    .join(" | ");
+
+  const eagerEntries = hasLazy
+    ? entries.filter((entry) => loadOnInitSet.has(entry.namespace))
+    : entries;
+
+  const typesContent = formatTypesFile({
+    isSingle,
+    entries,
+    projectRoot,
+    typesOutputPath,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    localeFallbackTypeName,
+    localeFallback: config.localeFallback,
+    paramsByNamespace,
+    requestLocaleUnion,
+    hasLazy,
+    loadOnInitSet,
+    lazyEntries,
+  });
+
+  const dictionaryContent = formatDictionaryFile({
+    isSingle,
+    hasLazy,
+    entries,
+    eagerEntries,
+    projectRoot,
+    dictionaryOutputPath,
+    typesOutputPath,
+    schemaTypeName,
+  });
+
+  const instanceContent = formatInstanceFile({
+    isSingle,
+    hasLazy,
+    typesOutputPath,
+    dictionaryOutputPath,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    factoryName,
+    hasLocaleFallback: Boolean(config.localeFallback),
+  });
+
+  fs.mkdirSync(path.dirname(typesOutputPath), { recursive: true });
+  fs.writeFileSync(typesOutputPath, typesContent);
+
+  fs.mkdirSync(path.dirname(dictionaryOutputPath), { recursive: true });
+  fs.writeFileSync(dictionaryOutputPath, dictionaryContent);
+
+  fs.mkdirSync(path.dirname(instanceOutputPath), { recursive: true });
+  fs.writeFileSync(instanceOutputPath, instanceContent);
+
+  const generatedFiles = [
+    path.relative(projectRoot, typesOutputPath),
+    path.relative(projectRoot, dictionaryOutputPath),
+    path.relative(projectRoot, instanceOutputPath),
+  ];
+
+  if (config.dictionarySchemaOutput) {
+    const dictionarySchemaOutputPath = path.resolve(projectRoot, config.dictionarySchemaOutput);
+    const dictionarySpecBlock = formatDictionarySpecBlock(isSingle, entries, argsSpecByNamespace);
+    const dictionarySchemaContent = formatDictionarySchemaFile(
+      schemaTypeName,
+      typesModule,
+      isSingle,
+      dictionarySpecBlock
+    );
+
+    fs.mkdirSync(path.dirname(dictionarySchemaOutputPath), { recursive: true });
+    fs.writeFileSync(dictionarySchemaOutputPath, dictionarySchemaContent);
+    generatedFiles.push(path.relative(projectRoot, dictionarySchemaOutputPath));
+  }
+
+  if (hasLazy) {
+    const namespaceLoadersOutputPath = path.resolve(
+      projectRoot,
+      config.namespaceLoadersOutput ??
+        path.join(path.dirname(config.instanceOutput), "namespace-loaders.generated.ts")
+    );
+    const dictionarySchemaOutputPath = path.resolve(projectRoot, config.dictionarySchemaOutput!);
+    const lazyEntriesWithPaths = lazyEntries.map((entry) => ({
+      ...entry,
+      absolutePath: path.resolve(projectRoot, entry.filePath),
+    }));
+    const namespaceLoadersContent = formatNamespaceLoadersFile(
+      namespaceLoadersOutputPath,
+      lazyEntriesWithPaths,
+      schemaTypeName,
+      typesModule,
+      toModuleBasename(dictionarySchemaOutputPath),
+      toModuleBasename(instanceOutputPath),
+      factoryName
+    );
+
+    fs.mkdirSync(path.dirname(namespaceLoadersOutputPath), { recursive: true });
+    fs.writeFileSync(namespaceLoadersOutputPath, namespaceLoadersContent);
+    generatedFiles.push(path.relative(projectRoot, namespaceLoadersOutputPath));
+  }
+
+  console.log(`✅ Generated: ${generatedFiles.join(", ")}`);
+}
+
+main();