@xndrjs/i18n 0.7.0 → 0.8.0

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

@@ -1,277 +1,15 @@
-import fs from "node:fs";
-import path from "node:path";
-import {
-  loadConfig,
-  resolveDeliveryOutputDir,
-  resolveDictionaryOutputPath,
-  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 { getDeliveryArtifactsIssues, getDeliveryArtifactsTypeName } from "./delivery-artifacts.js";
-import { collectRequestLocales, getCodegenLocaleFallbackIssues } from "./locale-fallback.js";
-import { enrichLocaleFallback } from "./locale-policy.js";
-import { reportCodegenIssues, resolveImportExtension, toModuleBasename } from "./paths.js";
-import { prepareDictionaryEntries } from "./read-dictionary.js";
-import { writeFileIfChanged } from "./write-file-if-changed.js";
-
 /**
- * Codegen CLI entry point. Pipeline:
- * config → analyze (ICU + types input) → validate locale/delivery policy →
- * prepare artifacts (YAML→JSON, split) → resolve lazy/eager → emit generated .ts files.
+ * 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 = path.resolve(
-    process.cwd(),
-    configArgIndex >= 0 ? process.argv[configArgIndex + 1]! : "i18n/i18n.codegen.json"
-  );
-  const projectRoot = path.dirname(configPath);
-
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`[Codegen Error] Config file not found: ${configPath}`);
-  }
-
-  const config = loadConfig(configPath);
-  const sourceEntries = resolveNamespaces(config);
-  const deliveryOutputRelative = resolveDeliveryOutputDir(config);
-  const delivery = config.delivery ?? "canonical";
-  const isSingle = Boolean(config.dictionary);
-
-  const analysisResult = analyzeDictionaries(projectRoot, sourceEntries);
-  if (!analysisResult.ok) {
-    process.exit(1);
-  }
-
-  const { paramsByNamespace, argsSpecByNamespace, locales, dictionariesByNamespace } =
-    analysisResult.analysis;
-
-  if (config.localeFallback) {
-    const localeFallbackIssues = getCodegenLocaleFallbackIssues(config.localeFallback, locales);
-    if (localeFallbackIssues.length > 0) {
-      reportCodegenIssues(localeFallbackIssues);
-      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 importExtension = resolveImportExtension(config);
-
-  const requestLocales = collectRequestLocales(locales, config.localeFallback);
-  const requestLocalesList = [...requestLocales].sort();
-
-  if (delivery === "custom" && config.deliveryArtifacts) {
-    const deliveryArtifactsIssues = getDeliveryArtifactsIssues(
-      config.deliveryArtifacts,
-      requestLocales
-    );
-    if (deliveryArtifactsIssues.length > 0) {
-      reportCodegenIssues(deliveryArtifactsIssues);
-      process.exit(1);
-    }
-  }
-
-  const {
-    resolvedEntries: entries,
-    splitPathsByNamespace,
-    compiledFiles,
-  } = prepareDictionaryEntries(projectRoot, sourceEntries, deliveryOutputRelative, {
-    dictionariesByNamespace,
-    delivery,
-    localeFallback: config.localeFallback,
-    requestLocales: delivery === "split-by-locale" ? requestLocalesList : undefined,
-    deliveryArtifacts: delivery === "custom" ? config.deliveryArtifacts : undefined,
-  });
-
-  const { loadOnInitSet, lazyEntries, hasLazy } = resolveLoadOnInit(config, entries, isSingle);
-
-  const typesOutputPath = path.resolve(projectRoot, config.typesOutput);
-  const dictionaryOutputPath = path.resolve(projectRoot, resolveDictionaryOutputPath(config));
-  const instanceOutputPath = path.resolve(projectRoot, config.instanceOutput);
-  const typesModule = toModuleBasename(typesOutputPath);
-
-  const requestLocaleUnion = requestLocalesList
-    .sort()
-    .map((locale) => `'${locale}'`)
-    .join(" | ");
-
-  const deliveryAreaNames =
-    delivery === "custom" && config.deliveryArtifacts
-      ? Object.keys(config.deliveryArtifacts).sort()
-      : undefined;
-  const deliveryAreaTypeName =
-    delivery === "custom" ? schemaTypeName.replace(/Schema$/, "DeliveryArea") : undefined;
-  const deliveryAreaUnion = deliveryAreaNames
-    ? deliveryAreaNames.map((area) => `'${area}'`).join(" | ")
-    : undefined;
-
-  const eagerEntries = hasLazy
-    ? entries.filter((entry) => loadOnInitSet.has(entry.namespace))
-    : entries;
-
-  const localeFallbackForEmit = config.localeFallback
-    ? enrichLocaleFallback(locales, config.localeFallback)
-    : undefined;
-
-  const typesContent = formatTypesFile({
-    isSingle,
-    entries,
-    projectRoot,
-    typesOutputPath,
-    paramsTypeName,
-    schemaTypeName,
-    localeTypeName,
-    localeFallbackConstName,
-    localeFallbackTypeName,
-    localeFallback: localeFallbackForEmit,
-    paramsByNamespace,
-    requestLocaleUnion,
-    ...(deliveryAreaTypeName && deliveryAreaUnion
-      ? {
-          deliveryAreaTypeName,
-          deliveryAreaUnion,
-          ...(delivery === "custom" && config.deliveryArtifacts
-            ? { deliveryArtifacts: config.deliveryArtifacts }
-            : {}),
-        }
-      : {}),
-    hasLazy,
-    loadOnInitSet,
-    lazyEntries,
-  });
-
-  const dictionaryContent = formatDictionaryFile({
-    isSingle,
-    hasLazy,
-    entries,
-    eagerEntries,
-    projectRoot,
-    dictionaryOutputPath,
-    typesOutputPath,
-    schemaTypeName,
-    localeTypeName,
-    importExtension,
-    delivery,
-    splitPathsByNamespace,
-    ...(delivery === "split-by-locale" ? { requestLocales: requestLocalesList } : {}),
-    ...(delivery === "custom" && deliveryAreaTypeName && deliveryAreaNames
-      ? { deliveryAreaTypeName, deliveryAreaNames }
-      : {}),
-  });
-
-  const instanceContent = formatInstanceFile({
-    isSingle,
-    hasLazy,
-    typesOutputPath,
-    ...(hasLazy
-      ? {
-          namespaceLoadersOutputPath: path.resolve(
-            projectRoot,
-            config.namespaceLoadersOutput ??
-              path.join(path.dirname(config.instanceOutput), "namespace-loaders.generated.ts")
-          ),
-        }
-      : {}),
-    paramsTypeName,
-    schemaTypeName,
-    localeTypeName,
-    localeFallbackConstName,
-    factoryName,
-    hasLocaleFallback: Boolean(config.localeFallback),
-    hasLocaleType: Boolean(requestLocaleUnion),
-    namespaceNames: entries.map((entry) => entry.namespace),
-    importExtension,
-    delivery,
-    ...(delivery === "custom" && deliveryAreaTypeName
-      ? {
-          deliveryAreaTypeName,
-          deliveryArtifactsTypeName: getDeliveryArtifactsTypeName(deliveryAreaTypeName),
-        }
-      : {}),
-  });
-
-  writeFileIfChanged(typesOutputPath, typesContent);
-
-  const generatedFiles = [
-    path.relative(projectRoot, typesOutputPath),
-    path.relative(projectRoot, instanceOutputPath),
-  ];
-
-  if (dictionaryContent !== null) {
-    writeFileIfChanged(dictionaryOutputPath, dictionaryContent);
-    generatedFiles.splice(1, 0, path.relative(projectRoot, dictionaryOutputPath));
-  } else if (fs.existsSync(dictionaryOutputPath)) {
-    fs.unlinkSync(dictionaryOutputPath);
-  }
-
-  writeFileIfChanged(instanceOutputPath, instanceContent);
-
-  if (config.dictionarySchemaOutput) {
-    const dictionarySchemaOutputPath = path.resolve(projectRoot, config.dictionarySchemaOutput);
-    const dictionarySpecBlock = formatDictionarySpecBlock(isSingle, entries, argsSpecByNamespace);
-    const dictionarySchemaContent = formatDictionarySchemaFile(
-      schemaTypeName,
-      typesModule,
-      isSingle,
-      dictionarySpecBlock,
-      importExtension
-    );
-
-    writeFileIfChanged(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 lazyEntriesWithPaths = lazyEntries.map((entry) => ({
-      ...entry,
-      absolutePath: path.resolve(projectRoot, entry.filePath),
-    }));
-    const namespaceLoadersContent = formatNamespaceLoadersFile({
-      loadersOutputPath: namespaceLoadersOutputPath,
-      lazyEntries: lazyEntriesWithPaths,
-      schemaTypeName,
-      paramsTypeName,
-      localeTypeName,
-      localeFallbackConstName,
-      hasLocaleFallback: Boolean(config.localeFallback),
-      typesModule,
-      importExtension,
-      projectRoot,
-      isSingle,
-      delivery,
-      splitPathsByNamespace,
-      ...(delivery === "split-by-locale" ? { requestLocales: requestLocalesList } : {}),
-      ...(delivery === "custom" && deliveryAreaTypeName && deliveryAreaNames
-        ? { deliveryAreaTypeName, deliveryAreaNames }
-        : {}),
-    });
-
-    writeFileIfChanged(namespaceLoadersOutputPath, namespaceLoadersContent);
-    generatedFiles.push(path.relative(projectRoot, namespaceLoadersOutputPath));
-  }
+  const configPath =
+    configArgIndex >= 0 ? process.argv[configArgIndex + 1]! : "i18n/i18n.codegen.json";
 
-  console.log(`✅ Generated: ${generatedFiles.join(", ")}`);
-  if (compiledFiles.length > 0) {
-    console.log(`✅ Compiled: ${compiledFiles.join(", ")}`);
-  }
+  runCodegen(path.resolve(process.cwd(), configPath));
 }
 
 try {

package/src/codegen/paths.ts

@@ -1,7 +1,5 @@
 import path from "node:path";
 import type { ImportExtension } from "./types.js";
-import { SUPPORTED_IMPORT_EXTENSIONS } from "./constants.js";
-import { CodegenConfig } from "./codegen-config-schema.js";
 
 export const GENERATED_FILE_BANNER = "// Automatically generated code. Do not edit manually.\n";
 export const DEFAULT_IMPORT_EXTENSION: ImportExtension = "none";
@@ -22,18 +20,6 @@ export function toModuleBasename(filePath: string): string {
   return path.basename(filePath).replace(/\.ts$/, "");
 }
 
-export function resolveImportExtension(
-  config: Pick<CodegenConfig, "importExtension">
-): ImportExtension {
-  const extension = config.importExtension ?? DEFAULT_IMPORT_EXTENSION;
-  if (!SUPPORTED_IMPORT_EXTENSIONS.includes(extension)) {
-    throw new Error(
-      `[Codegen Error] importExtension must be "none", ".ts", or ".js", got ${JSON.stringify(extension)}.`
-    );
-  }
-  return extension;
-}
-
 export function importExtensionSuffix(importExtension: ImportExtension): string {
   return importExtension === "none" ? "" : importExtension;
 }

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

@@ -3,14 +3,11 @@ 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, expectTypeOf, it } from "vitest";
-import billingDictionary from "./fixtures/billing-namespace.json";
+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));
 
-type BillingNamespace = typeof billingDictionary;
-
 function runCodegen(cwd: string) {
   return spawnSync("tsx", [codegenScript, "--config", "i18n.codegen.json"], {
     cwd,
@@ -49,15 +46,12 @@ function setupMultiCodegenFixture(tempDir: string) {
   writeFileSync(
     join(tempDir, "i18n.codegen.json"),
     JSON.stringify({
+      projectName: "App",
       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",
+      codegenPath: "src/i18n",
       localeFallback: {
         en: null,
         it: "en",
@@ -85,6 +79,7 @@ function writeTscProject(tempDir: string) {
           skipLibCheck: true,
           paths: {
             "@xndrjs/i18n": [join(packageRoot, "src/index.ts")],
+            "@xndrjs/i18n/validation": [join(packageRoot, "src/validation/index.ts")],
           },
         },
         include: ["src/**/*.ts"],
@@ -95,82 +90,45 @@ function writeTscProject(tempDir: string) {
   );
 }
 
-describe("codegen projectNamespaceLocales + load + scope.set", () => {
-  describe("generated instance output", () => {
-    let tempDir: string;
-
-    afterEach(() => {
-      if (tempDir) {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    it("emits projectNamespaceLocales for multi mode with schema-typed namespace payloads", () => {
-      tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-project-locales-"));
-      setupMultiCodegenFixture(tempDir);
-
-      const factory = readFileSync(join(tempDir, "src/i18n/instance.generated.ts"), "utf8");
-      expect(factory).toContain('dictionary: AppSchema["billing"]');
-      expect(factory).toContain("export function projectNamespaceLocales(");
-      expect(factory).toContain(
-        "projectDictionaryLocalesCore(dictionary, locales, LOCALE_FALLBACK)"
-      );
-    });
-
-    it("passes tsc when hydrating with projectNamespaceLocales via load() and scope.set()", () => {
-      tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-project-locales-"));
-      setupMultiCodegenFixture(tempDir);
-
-      writeFileSync(
-        join(tempDir, "src/hydrate-billing.ts"),
-        [
-          `import { createI18nMultiBuilder, IcuTranslationProviderMulti } from "@xndrjs/i18n";`,
-          `import { projectNamespaceLocales } from "./i18n/instance.generated.js";`,
-          `import { defaultDictionary } from "./i18n/dictionary.generated.js";`,
-          `import type { AppSchema, AppParams } from "./i18n/i18n-types.generated.js";`,
-          `import billingDictionary from "./i18n/translations/billing.json";`,
-          ``,
-          `async function hydrateBilling() {`,
-          `  const billingEn = projectNamespaceLocales(billingDictionary, ["en"]);`,
-          `  const engine = new IcuTranslationProviderMulti<AppSchema, AppParams>(defaultDictionary);`,
-          `  const view = await createI18nMultiBuilder(engine, {`,
-          `    namespaceLoaders: {`,
-          `      billing: async () => billingEn,`,
-          `    },`,
-          `  })`,
-          `    .withNamespaces(["billing"])`,
-          `    .withLocale("en")`,
-          `    .load();`,
-          ``,
-          `  view.set(`,
-          `    "billing",`,
-          `    "invoice_summary",`,
-          `    "You have {count, plural, one {1 invoice} other {{count} invoices}}"`,
-          `  );`,
-          `  return view.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);
-    });
-
-    it("types projectNamespaceLocales result as the namespace schema", () => {
-      type AppSchema = {
-        billing: BillingNamespace;
-      };
-
-      type ProjectNamespaceLocalesBilling = (
-        dictionary: AppSchema["billing"],
-        locales: readonly ("en" | "it")[]
-      ) => AppSchema["billing"];
-
-      expectTypeOf<ReturnType<ProjectNamespaceLocalesBilling>>().toEqualTypeOf<BillingNamespace>();
-    });
+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);
   });
 });

package/src/codegen/read-dictionary.test.ts

@@ -105,7 +105,7 @@ describe("read-dictionary", () => {
     expect(() => readDictionaryFile(jsonPath)).not.toThrow();
   });
 
-  it("compiles yaml sources to json under the generated output directory", () => {
+  it("compiles yaml sources into per-locale split files", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-read-dict-"));
     mkdirSync(join(tempDir, "src/i18n/translations"), { recursive: true });
     mkdirSync(join(tempDir, "src/i18n/generated"), { recursive: true });
@@ -121,6 +121,8 @@ describe("read-dictionary", () => {
       [{ namespace: "billing", filePath: "src/i18n/translations/billing.yaml" }],
       "src/i18n/generated",
       {
+        delivery: "split-by-locale",
+        requestLocales: ["en"],
         dictionariesByNamespace: {
           billing: readDictionaryFile(join(tempDir, "src/i18n/translations/billing.yaml")),
         },
@@ -128,20 +130,24 @@ describe("read-dictionary", () => {
     );
 
     expect(result.resolvedEntries).toEqual([
-      { namespace: "billing", filePath: "src/i18n/generated/translations/billing.json" },
+      { namespace: "billing", filePath: "src/i18n/translations/billing.yaml" },
     ]);
-    expect(result.splitPathsByNamespace).toEqual({});
+    expect(result.splitPathsByNamespace).toEqual({
+      billing: {
+        en: "src/i18n/generated/translations/billing.en.json",
+      },
+    });
     expect(result.compiledFiles).toEqual([
-      "src/i18n/translations/billing.yaml → src/i18n/generated/translations/billing.json",
+      "src/i18n/translations/billing.yaml → src/i18n/generated/translations/billing.en.json",
     ]);
 
     const compiled = JSON.parse(
-      readFileSync(join(tempDir, "src/i18n/generated/translations/billing.json"), "utf8")
+      readFileSync(join(tempDir, "src/i18n/generated/translations/billing.en.json"), "utf8")
     ) as Record<string, Record<string, string>>;
     expect(compiled.invoice_summary?.en).toBe("You have {count} invoices");
   });
 
-  it("keeps json sources unchanged", () => {
+  it("splits json sources into per-locale files", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-read-dict-"));
     mkdirSync(join(tempDir, "translations"), { recursive: true });
     writeFileSync(
@@ -154,6 +160,8 @@ describe("read-dictionary", () => {
       [{ namespace: "default", filePath: "translations/default.json" }],
       "generated",
       {
+        delivery: "split-by-locale",
+        requestLocales: ["en"],
         dictionariesByNamespace: {
           default: readDictionaryFile(join(tempDir, "translations/default.json")),
         },
@@ -163,8 +171,14 @@ describe("read-dictionary", () => {
     expect(result.resolvedEntries).toEqual([
       { namespace: "default", filePath: "translations/default.json" },
     ]);
-    expect(result.splitPathsByNamespace).toEqual({});
-    expect(result.compiledFiles).toEqual([]);
+    expect(result.splitPathsByNamespace).toEqual({
+      default: {
+        en: "generated/translations/default.en.json",
+      },
+    });
+    expect(result.compiledFiles).toEqual([
+      "translations/default.json → generated/translations/default.en.json",
+    ]);
   });
 
   it("splits multiple namespaces into per-locale files", () => {
@@ -405,7 +419,11 @@ describe("read-dictionary", () => {
         tempDir,
         [{ namespace: "default", filePath: "translations/default.json" }],
         "generated",
-        { dictionariesByNamespace: {} }
+        {
+          delivery: "split-by-locale",
+          requestLocales: ["en"],
+          dictionariesByNamespace: {},
+        }
       )
     ).toThrow('[Codegen Error] Missing parsed dictionary for namespace "default".');
   });

package/src/codegen/read-dictionary.ts

@@ -142,7 +142,7 @@ function writeCompiledJson(absoluteJsonPath: string, dictionary: DictionaryJson)
 
 export interface PrepareDictionaryEntriesOptions {
   dictionariesByNamespace: Record<string, DictionaryJson>;
-  delivery?: DeliveryMode;
+  delivery: DeliveryMode;
   localeFallback?: LocaleFallbackMap | undefined;
   requestLocales?: readonly string[] | undefined;
   deliveryArtifacts?: DeliveryArtifactsMap | undefined;
@@ -155,8 +155,8 @@ export interface PrepareDictionariesResult {
 }
 
 /**
- * Phase 2 of codegen: materialize JSON artifacts on disk (YAML compile, locale/area split).
- * Returns `splitPathsByNamespace` consumed by dictionary and namespace-loader emitters.
+ * Phase 2 of codegen: materialize JSON artifacts on disk (locale/area split).
+ * Returns `splitPathsByNamespace` consumed by namespace-loader emitters.
  */
 export function prepareDictionaryEntries(
   projectRoot: string,
@@ -164,7 +164,7 @@ export function prepareDictionaryEntries(
   generatedDirRelative: string,
   options: PrepareDictionaryEntriesOptions
 ): PrepareDictionariesResult {
-  const delivery = options.delivery ?? "canonical";
+  const delivery = options.delivery;
   const { dictionariesByNamespace, localeFallback, requestLocales, deliveryArtifacts } = options;
   const resolvedEntries: NamespaceEntry[] = [];
   const splitPathsByNamespace: Record<string, Record<string, string>> = {};
@@ -231,50 +231,28 @@ export function prepareDictionaryEntries(
       continue;
     }
 
-    if (delivery === "custom") {
-      const splitPaths: Record<string, string> = {};
-      const dictionariesByArea = splitDictionaryByDeliveryArea(
-        dictionary,
-        deliveryArtifacts!,
-        localeFallback
-      );
-
-      for (const area of Object.keys(deliveryArtifacts!).sort()) {
-        const areaRelativePath = resolveAreaJsonPath(entry.filePath, area, generatedDirRelative);
-        const areaAbsolutePath = path.resolve(projectRoot, areaRelativePath);
-        const wroteFile = writeCompiledJson(areaAbsolutePath, dictionariesByArea[area]!);
-
-        if (wroteFile) {
-          compiledFiles.push(
-            `${path.relative(projectRoot, sourceAbsolutePath)} → ${areaRelativePath}`
-          );
-        }
-
-        splitPaths[area] = areaRelativePath;
-      }
-
-      splitPathsByNamespace[entry.namespace] = splitPaths;
-      resolvedEntries.push(entry);
-      continue;
-    }
+    const splitPaths: Record<string, string> = {};
+    const dictionariesByArea = splitDictionaryByDeliveryArea(
+      dictionary,
+      deliveryArtifacts!,
+      localeFallback
+    );
 
-    if (format === "yaml") {
-      const compiledRelativePath = resolveCompiledJsonPath(entry.filePath, generatedDirRelative);
-      const compiledAbsolutePath = path.resolve(projectRoot, compiledRelativePath);
-      const wroteFile = writeCompiledJson(compiledAbsolutePath, dictionary);
+    for (const area of Object.keys(deliveryArtifacts!).sort()) {
+      const areaRelativePath = resolveAreaJsonPath(entry.filePath, area, generatedDirRelative);
+      const areaAbsolutePath = path.resolve(projectRoot, areaRelativePath);
+      const wroteFile = writeCompiledJson(areaAbsolutePath, dictionariesByArea[area]!);
 
       if (wroteFile) {
         compiledFiles.push(
-          `${path.relative(projectRoot, sourceAbsolutePath)} → ${compiledRelativePath}`
+          `${path.relative(projectRoot, sourceAbsolutePath)} → ${areaRelativePath}`
         );
       }
-      resolvedEntries.push({
-        namespace: entry.namespace,
-        filePath: compiledRelativePath,
-      });
-      continue;
+
+      splitPaths[area] = areaRelativePath;
     }
 
+    splitPathsByNamespace[entry.namespace] = splitPaths;
     resolvedEntries.push(entry);
   }