@xndrjs/i18n 0.8.0 → 0.8.2-alpha.0

package/src/IcuTranslationProviderMulti.test.ts

@@ -1,215 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { IcuTranslationProviderMulti } from "./IcuTranslationProviderMulti.js";
-
-type TestSchema = {
-  default: {
-    login_button: { en: string; it: string };
-    welcome: { en: string };
-    dashboard_status: { en: string; it: string };
-    inbox_owner: { en: string; it: string };
-    ranking_position: { en: string; it: string };
-  };
-  billing: {
-    invoice_summary: { en: string; it: string };
-    account_balance: { en: string; it: string };
-    appointment_summary: { en: string; it: string };
-    empty_label: { en: string };
-  };
-};
-
-type TestParams = {
-  default: {
-    login_button: never;
-    welcome: { name: string };
-    dashboard_status: { msgCount: number; chatCount: number };
-    inbox_owner: { gender: string; name: string };
-    ranking_position: { position: number };
-  };
-  billing: {
-    invoice_summary: { count: number; name: string };
-    account_balance: { amount: number };
-    appointment_summary: { dueDate: Date | number; startTime: Date | number };
-    empty_label: never;
-  };
-};
-
-const dictionary: TestSchema = {
-  default: {
-    login_button: { en: "Login", it: "Accedi" },
-    welcome: { en: "Welcome {name}!" },
-    dashboard_status: {
-      en: "You have {msgCount, plural, one {1 message} other {{msgCount} messages}} in {chatCount, plural, one {one chat} other {{chatCount} chats}}",
-      it: "Hai {msgCount, plural, one {1 messaggio} other {{msgCount} messaggi}} in {chatCount, plural, one {una chat} other {{chatCount} chat}}",
-    },
-    inbox_owner: {
-      en: "{gender, select, female {{name} owns her inbox} male {{name} owns his inbox} other {{name} owns their inbox}}",
-      it: "{gender, select, female {{name} gestisce la sua casella} male {{name} gestisce la sua casella} other {{name} gestisce la propria casella}}",
-    },
-    ranking_position: {
-      en: "You finished {position, selectordinal, one {#st} two {#nd} few {#rd} other {#th}}",
-      it: "Hai concluso al {position, selectordinal, one {#°} other {#°}} posto",
-    },
-  },
-  billing: {
-    invoice_summary: {
-      en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-      it: "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}",
-    },
-    account_balance: {
-      en: "Balance: {amount, number, ::currency/EUR}",
-      it: "Saldo: {amount, number, ::currency/EUR}",
-    },
-    appointment_summary: {
-      en: "Due {dueDate, date, short} at {startTime, time, short}",
-      it: "Scade il {dueDate, date, short} alle {startTime, time, short}",
-    },
-    empty_label: { en: "" },
-  },
-};
-
-describe("IcuTranslationProviderMulti", () => {
-  const engine = new IcuTranslationProviderMulti<TestSchema, TestParams>(dictionary);
-
-  it("tracks namespaces via dictionary keys", () => {
-    const partial = new IcuTranslationProviderMulti<TestSchema, TestParams>({
-      default: dictionary.default,
-    });
-
-    expect("default" in partial.getAll()).toBe(true);
-    expect("billing" in partial.getAll()).toBe(false);
-  });
-
-  it("supports partial initialization", () => {
-    const partial = new IcuTranslationProviderMulti<TestSchema, TestParams>({
-      default: dictionary.default,
-    });
-
-    expect(partial.toScope({ namespaces: ["default"] }).t("default", "login_button", "en")).toBe(
-      "Login"
-    );
-  });
-
-  it("adds namespace to dictionary with applyLoadMergeNamespace", () => {
-    const partial = new IcuTranslationProviderMulti<TestSchema, TestParams>({
-      default: dictionary.default,
-    });
-    expect("billing" in partial.getAll()).toBe(false);
-
-    partial.applyLoadMergeNamespace("billing", dictionary.billing);
-    expect("billing" in partial.getAll()).toBe(true);
-  });
-
-  it("adds namespace to dictionary on first applyLoadMergeNamespace", () => {
-    const partial = new IcuTranslationProviderMulti<TestSchema, TestParams>({});
-    expect("billing" in partial.getAll()).toBe(false);
-
-    partial.applyLoadMergeNamespace("billing", dictionary.billing);
-    expect("billing" in partial.getAll()).toBe(true);
-  });
-
-  it("accumulates a locale via applyLoadMergeNamespace when the namespace already exists", () => {
-    const local = new IcuTranslationProviderMulti<TestSchema, TestParams>({
-      billing: {
-        invoice_summary: {
-          en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-        },
-      },
-    });
-    const view = () => local.toScope({ namespaces: ["billing"] });
-
-    expect("billing" in local.getAll()).toBe(true);
-    expect(view().t("billing", "invoice_summary", "en", { count: 1, name: "Ada" })).toBe(
-      "You have 1 invoice for Ada"
-    );
-
-    local.applyLoadMergeNamespace("billing", {
-      invoice_summary: {
-        it: "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}",
-      },
-    });
-
-    expect(view().t("billing", "invoice_summary", "en", { count: 2, name: "Bob" })).toBe(
-      "You have 2 invoices for Bob"
-    );
-    expect(view().t("billing", "invoice_summary", "it", { count: 2, name: "Bob" })).toBe(
-      "Hai 2 fatture per Bob"
-    );
-  });
-
-  it("merges locales per key with applyLoadMergeNamespace without dropping existing locales", () => {
-    const local = new IcuTranslationProviderMulti<TestSchema, TestParams>({
-      billing: {
-        invoice_summary: {
-          en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-        },
-      },
-    });
-    const view = () => local.toScope({ namespaces: ["billing"] });
-
-    local.applyLoadMergeNamespace("billing", {
-      invoice_summary: {
-        it: "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}",
-      },
-    });
-
-    expect(view().t("billing", "invoice_summary", "en", { count: 2, name: "Bob" })).toBe(
-      "You have 2 invoices for Bob"
-    );
-    expect(view().t("billing", "invoice_summary", "it", { count: 2, name: "Bob" })).toBe(
-      "Hai 2 fatture per Bob"
-    );
-  });
-
-  it("merges namespaces with applyLoadMergeAll without dropping existing locales", () => {
-    const local = new IcuTranslationProviderMulti<TestSchema, TestParams>({
-      billing: {
-        invoice_summary: {
-          en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-        },
-      },
-    });
-    const view = () => local.toScope({ namespaces: ["default", "billing"] });
-
-    local.applyLoadMergeAll({
-      billing: {
-        invoice_summary: {
-          it: "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}",
-        },
-      },
-      default: dictionary.default,
-    });
-
-    expect(view().t("billing", "invoice_summary", "en", { count: 2, name: "Bob" })).toBe(
-      "You have 2 invoices for Bob"
-    );
-    expect(view().t("billing", "invoice_summary", "it", { count: 2, name: "Bob" })).toBe(
-      "Hai 2 fatture per Bob"
-    );
-    expect(view().t("default", "login_button", "en")).toBe("Login");
-  });
-
-  it("returns the live dictionary from getAll (constructor clones the input)", () => {
-    expect(engine.getAll()).toEqual(dictionary);
-    expect(engine.getAll()).not.toBe(dictionary);
-    expect(engine.getAll()).toBe(engine.getAll());
-  });
-
-  it("invalidates compiled cache when applyLoadMergeNamespace overwrites a key", () => {
-    const local = new IcuTranslationProviderMulti<TestSchema, TestParams>(dictionary);
-    const view = () => local.toScope({ namespaces: ["billing"] });
-
-    expect(view().t("billing", "invoice_summary", "en", { count: 2, name: "Bob" })).toBe(
-      "You have 2 invoices for Bob"
-    );
-
-    local.applyLoadMergeNamespace("billing", {
-      invoice_summary: {
-        en: "{count, plural, one {1 bill} other {{count} bills}} for {name}",
-      },
-    });
-
-    expect(view().t("billing", "invoice_summary", "en", { count: 2, name: "Bob" })).toBe(
-      "2 bills for Bob"
-    );
-  });
-});

package/src/IcuTranslationProviderMulti.ts

@@ -1,176 +0,0 @@
-import { BuilderLoadRegistry, type BuilderResourceEntry } from "./builder-load-registry.js";
-import type { I18nEngineMulti } from "./engine.js";
-import type { I18nSerializedState } from "./serialized-state.js";
-import { resolveAndFormat } from "./format-core.js";
-import { mergeNamespaceLocalesCore } from "./project-locales.js";
-import { validateLocaleFallback } from "./resolve-locale.js";
-import type {
-  IcuTranslationProviderOptions,
-  LocaleFallbackMap,
-  LocaleOfMulti,
-  MultiCompiledCache,
-  MultiDictionary,
-  OnMissingTranslation,
-  PartialKeyDictionary,
-  PartialMultiDictionary,
-} from "./types.js";
-import { I18nScopeMultiForLocaleImpl, I18nScopeMultiImpl } from "./scope-multi.js";
-import type { I18nScopeMulti, I18nScopeMultiForLocale } from "./scope-multi.js";
-import type { MultiParams, ParamsForNamespaces, SchemaForNamespaces } from "./scope-types.js";
-
-export class IcuTranslationProviderMulti<
-  Schema extends MultiDictionary,
-  Params extends MultiParams<Schema>,
-  RequestLocales extends string = LocaleOfMulti<Schema>,
-  Fallback extends LocaleFallbackMap | undefined = undefined,
-> implements I18nEngineMulti<Schema, Params, RequestLocales> {
-  readonly __i18nEngineMode = "multi" as const;
-
-  /** Loaded namespaces only — cold start is `{}`; never claim full Schema until loaded. */
-  private dictionary: PartialMultiDictionary<Schema, RequestLocales>;
-  private compiledCache: MultiCompiledCache = {};
-  private readonly builderLoadRegistry = new BuilderLoadRegistry();
-  private readonly localeFallback?: Fallback;
-  private readonly onMissing: OnMissingTranslation;
-
-  constructor(
-    dictionary: PartialMultiDictionary<Schema, RequestLocales> = {},
-    options?: IcuTranslationProviderOptions<Fallback>
-  ) {
-    this.dictionary = structuredClone(dictionary);
-    if (options?.localeFallback) {
-      validateLocaleFallback(options.localeFallback);
-      this.localeFallback = options.localeFallback;
-    }
-    this.onMissing = options?.onMissing ?? "throw";
-  }
-
-  getWithLocale(
-    namespace: string,
-    key: string,
-    locale: string,
-    params?: Record<string, unknown>
-  ): string {
-    const localeByKey = (
-      this.dictionary[namespace as keyof Schema] as
-        | Record<string, Record<string, string>>
-        | undefined
-    )?.[key];
-
-    return resolveAndFormat({
-      localeByKey,
-      locale,
-      params,
-      getCache: (resolvedLocale) => {
-        if (!this.compiledCache[resolvedLocale]) {
-          this.compiledCache[resolvedLocale] = {};
-        }
-        if (!this.compiledCache[resolvedLocale]![namespace]) {
-          this.compiledCache[resolvedLocale]![namespace] = {};
-        }
-        return this.compiledCache[resolvedLocale]![namespace]!;
-      },
-      context: {
-        namespace,
-        key,
-        locale,
-        localeFallback: this.localeFallback,
-        onMissing: this.onMissing,
-      },
-    });
-  }
-
-  toScope<
-    NsList extends readonly (keyof Schema & string)[],
-    Locale extends RequestLocales,
-  >(options: {
-    namespaces: NsList;
-    locale: Locale;
-  }): I18nScopeMultiForLocale<
-    SchemaForNamespaces<Schema, NsList>,
-    ParamsForNamespaces<Schema, Params, NsList>,
-    RequestLocales,
-    Locale
-  >;
-  toScope<NsList extends readonly (keyof Schema & string)[]>(options: {
-    namespaces: NsList;
-  }): I18nScopeMulti<
-    SchemaForNamespaces<Schema, NsList>,
-    ParamsForNamespaces<Schema, Params, NsList>,
-    RequestLocales
-  >;
-  toScope<
-    NsList extends readonly (keyof Schema & string)[],
-    Locale extends RequestLocales,
-  >(options: { namespaces: NsList; locale?: Locale }) {
-    if (options.locale !== undefined) {
-      return new I18nScopeMultiForLocaleImpl(this, options.locale) as I18nScopeMultiForLocale<
-        SchemaForNamespaces<Schema, NsList>,
-        ParamsForNamespaces<Schema, Params, NsList>,
-        RequestLocales,
-        Locale
-      >;
-    }
-    return new I18nScopeMultiImpl(this) as I18nScopeMulti<
-      SchemaForNamespaces<Schema, NsList>,
-      ParamsForNamespaces<Schema, Params, NsList>,
-      RequestLocales
-    >;
-  }
-
-  /** Live dictionary reference (loaded namespaces only). Do not mutate. */
-  getAll(): PartialMultiDictionary<Schema, RequestLocales> {
-    return this.dictionary;
-  }
-
-  hasBuilderResourceLoaded(namespace: string, partition: string): boolean {
-    return this.builderLoadRegistry.has(namespace, partition);
-  }
-
-  markBuilderResourceLoaded(namespace: string, partition: string): void {
-    this.builderLoadRegistry.mark(namespace, partition);
-  }
-
-  seedBuilderResources(resources: readonly BuilderResourceEntry[]): void {
-    this.builderLoadRegistry.seed(resources);
-  }
-
-  serialize(): I18nSerializedState<PartialMultiDictionary<Schema, RequestLocales>> {
-    return {
-      dictionary: this.dictionary,
-      resources: this.builderLoadRegistry.entries(),
-    };
-  }
-
-  applyLoadMergeNamespace<NS extends keyof Schema>(
-    namespace: NS,
-    values: PartialKeyDictionary<Schema[NS], RequestLocales>
-  ): void {
-    const existing = (this.dictionary[namespace] ?? {}) as Schema[NS];
-    const merged = mergeNamespaceLocalesCore(existing, values);
-
-    this.dictionary = {
-      ...this.dictionary,
-      [namespace]: merged,
-    };
-
-    for (const [key, incomingLocales] of Object.entries(values)) {
-      if (incomingLocales === undefined || typeof incomingLocales !== "object") {
-        continue;
-      }
-
-      for (const locale of Object.keys(incomingLocales)) {
-        delete this.compiledCache[locale]?.[namespace as string]?.[key];
-      }
-    }
-  }
-
-  applyLoadMergeAll(values: PartialMultiDictionary<Schema, RequestLocales>): void {
-    for (const namespace of Object.keys(values) as (keyof Schema & string)[]) {
-      const incoming = values[namespace];
-      if (incoming !== undefined) {
-        this.applyLoadMergeNamespace(namespace, incoming);
-      }
-    }
-  }
-}

package/src/audit/audit-dictionaries.test.ts

@@ -1,134 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { auditDictionaries, reportHasGaps } from "./audit-dictionaries.js";
-
-describe("auditDictionaries", () => {
-  it("reports missingDirect for fallback-only locales while missingEffective stays empty when en covers", () => {
-    const report = auditDictionaries({
-      namespaces: {
-        default: {
-          login_button: { en: "Login", it: "Accedi" },
-        },
-      },
-      config: {
-        localeFallback: {
-          en: null,
-          "de-DE": "en",
-          "de-CH": "de-DE",
-          it: "en",
-        },
-      },
-    });
-
-    expect(report.requiredLocales).toEqual(["de-CH", "de-DE", "en", "it"]);
-    expect(report.missingDirectByLocale.default?.["de-CH"]).toEqual(["login_button"]);
-    expect(report.missingEffectiveByLocale.default?.["de-CH"]).toEqual([]);
-    expect(report.missingDirectByLocale.default?.en).toEqual([]);
-  });
-
-  it("treats empty strings as missing by default", () => {
-    const report = auditDictionaries({
-      namespaces: {
-        default: {
-          empty_label: { en: "" },
-        },
-      },
-      config: {},
-    });
-
-    expect(report.missingDirectByLocale.default?.en).toEqual(["empty_label"]);
-    expect(report.missingEffectiveByLocale.default?.en).toEqual(["empty_label"]);
-  });
-
-  it("allows empty strings when treatEmptyAsMissing is false", () => {
-    const report = auditDictionaries({
-      namespaces: {
-        default: {
-          empty_label: { en: "" },
-        },
-      },
-      config: {},
-      treatEmptyAsMissing: false,
-    });
-
-    expect(report.missingDirectByLocale.default?.en).toEqual([]);
-    expect(report.missingEffectiveByLocale.default?.en).toEqual([]);
-  });
-
-  it("uses enriched locale fallback for effective gaps", () => {
-    const report = auditDictionaries({
-      namespaces: {
-        default: {
-          welcome: { en: "Welcome {name}!" },
-        },
-      },
-      config: {
-        localeFallback: {
-          en: null,
-          it: "en",
-        },
-      },
-    });
-
-    expect(report.localeFallback).toEqual({
-      en: null,
-      it: "en",
-    });
-    expect(report.missingEffectiveByLocale.default?.it).toEqual([]);
-  });
-
-  it("matches direct and effective when localeFallback is absent", () => {
-    const report = auditDictionaries({
-      namespaces: {
-        default: {
-          login_button: { en: "Login" },
-        },
-      },
-      config: {},
-    });
-
-    expect(report.localeFallback).toBeUndefined();
-    expect(report.requiredLocales).toEqual(["en"]);
-    expect(report.missingDirectByLocale.default?.en).toEqual([]);
-    expect(report.missingEffectiveByLocale.default?.en).toEqual([]);
-  });
-
-  it("reports effective gaps when fallback chain cannot resolve", () => {
-    const report = auditDictionaries({
-      namespaces: {
-        default: {
-          login_button: { it: "Accedi" },
-        },
-      },
-      config: {
-        localeFallback: {
-          en: null,
-          it: "en",
-        },
-      },
-    });
-
-    expect(report.missingEffectiveByLocale.default?.en).toEqual(["login_button"]);
-  });
-});
-
-describe("reportHasGaps", () => {
-  const report = auditDictionaries({
-    namespaces: {
-      default: {
-        login_button: { en: "Login", it: "Accedi" },
-      },
-    },
-    config: {
-      localeFallback: {
-        en: null,
-        "de-CH": "en",
-      },
-    },
-  });
-
-  it("detects direct gaps", () => {
-    expect(reportHasGaps(report, "direct")).toBe(true);
-    expect(reportHasGaps(report, "effective")).toBe(false);
-    expect(reportHasGaps(report, "any")).toBe(true);
-  });
-});

package/src/audit/audit-dictionaries.ts

@@ -1,178 +0,0 @@
-import path from "node:path";
-import type { DictionaryJson } from "../codegen/types.js";
-import { buildRequiredLocales, enrichLocaleFallback } from "../codegen/locale-policy.js";
-import { resolveLocaleTemplate } from "../resolve-locale.js";
-import { CodegenConfig } from "../codegen/codegen-config-schema.js";
-
-export type FailOnCriterion = "effective" | "direct" | "any";
-
-export interface I18nAuditReport {
-  requiredLocales: string[];
-  localeFallback?: Record<string, string | null>;
-  summary: Record<string, Record<string, { missingDirect: number; missingEffective: number }>>;
-  missingDirectByLocale: Record<string, Record<string, string[]>>;
-  missingEffectiveByLocale: Record<string, Record<string, string[]>>;
-}
-
-export interface AuditDictionariesOptions {
-  namespaces: Record<string, DictionaryJson>;
-  config: Pick<CodegenConfig, "localeFallback">;
-  treatEmptyAsMissing?: boolean;
-}
-
-function isDirectlyMissing(
-  localesByKey: Record<string, string>,
-  locale: string,
-  treatEmptyAsMissing: boolean
-): boolean {
-  const template = localesByKey[locale];
-  if (template === undefined) {
-    return true;
-  }
-  return treatEmptyAsMissing && template === "";
-}
-
-function isEffectivelyMissing(
-  localesByKey: Record<string, string>,
-  locale: string,
-  localeFallback: Record<string, string | null> | undefined,
-  treatEmptyAsMissing: boolean
-): boolean {
-  const resolved = resolveLocaleTemplate(localesByKey, locale, localeFallback);
-  if (resolved === undefined) {
-    return true;
-  }
-  return treatEmptyAsMissing && resolved.template === "";
-}
-
-function collectDictionaryLocales(namespaces: Record<string, DictionaryJson>): Set<string> {
-  const locales = new Set<string>();
-
-  for (const dictionary of Object.values(namespaces)) {
-    for (const localesByKey of Object.values(dictionary)) {
-      for (const locale of Object.keys(localesByKey)) {
-        locales.add(locale);
-      }
-    }
-  }
-
-  return locales;
-}
-
-/**
- * Audit pipeline: reports missing translations per namespace/locale (direct and
- * effective via fallback), using the same locale policy as codegen.
- */
-export function auditDictionaries(options: AuditDictionariesOptions): I18nAuditReport {
-  const { namespaces, config, treatEmptyAsMissing = true } = options;
-  const dictionaryLocales = collectDictionaryLocales(namespaces);
-  const requiredLocales = buildRequiredLocales(dictionaryLocales, config.localeFallback);
-  const localeFallbackForAudit = config.localeFallback
-    ? enrichLocaleFallback(dictionaryLocales, config.localeFallback)
-    : undefined;
-
-  const summary: I18nAuditReport["summary"] = {};
-  const missingDirectByLocale: I18nAuditReport["missingDirectByLocale"] = {};
-  const missingEffectiveByLocale: I18nAuditReport["missingEffectiveByLocale"] = {};
-
-  for (const [namespace, dictionary] of Object.entries(namespaces)) {
-    summary[namespace] = {};
-    missingDirectByLocale[namespace] = {};
-    missingEffectiveByLocale[namespace] = {};
-
-    for (const locale of requiredLocales) {
-      summary[namespace]![locale] = { missingDirect: 0, missingEffective: 0 };
-      missingDirectByLocale[namespace]![locale] = [];
-      missingEffectiveByLocale[namespace]![locale] = [];
-    }
-
-    for (const [key, localesByKey] of Object.entries(dictionary)) {
-      for (const locale of requiredLocales) {
-        if (isDirectlyMissing(localesByKey, locale, treatEmptyAsMissing)) {
-          summary[namespace]![locale]!.missingDirect += 1;
-          missingDirectByLocale[namespace]![locale]!.push(key);
-        }
-
-        if (
-          isEffectivelyMissing(localesByKey, locale, localeFallbackForAudit, treatEmptyAsMissing)
-        ) {
-          summary[namespace]![locale]!.missingEffective += 1;
-          missingEffectiveByLocale[namespace]![locale]!.push(key);
-        }
-      }
-    }
-
-    for (const locale of requiredLocales) {
-      missingDirectByLocale[namespace]![locale]!.sort();
-      missingEffectiveByLocale[namespace]![locale]!.sort();
-    }
-  }
-
-  return {
-    requiredLocales,
-    ...(localeFallbackForAudit !== undefined ? { localeFallback: localeFallbackForAudit } : {}),
-    summary,
-    missingDirectByLocale,
-    missingEffectiveByLocale,
-  };
-}
-
-export function reportHasGaps(report: I18nAuditReport, criterion: FailOnCriterion): boolean {
-  for (const namespace of Object.keys(report.missingDirectByLocale)) {
-    for (const locale of report.requiredLocales) {
-      const direct = report.missingDirectByLocale[namespace]?.[locale] ?? [];
-      const effective = report.missingEffectiveByLocale[namespace]?.[locale] ?? [];
-
-      if (criterion === "direct" && direct.length > 0) {
-        return true;
-      }
-      if (criterion === "effective" && effective.length > 0) {
-        return true;
-      }
-      if (criterion === "any" && (direct.length > 0 || effective.length > 0)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-export interface RunAuditOptions {
-  projectRoot: string;
-  config: CodegenConfig;
-  treatEmptyAsMissing?: boolean;
-  failOn?: FailOnCriterion;
-}
-
-export interface RunAuditResult {
-  report: I18nAuditReport;
-  exitCode: 0 | 1;
-}
-
-export async function runAuditFromConfig(options: RunAuditOptions): Promise<RunAuditResult> {
-  const { resolveNamespaces } = await import("../codegen/config.js");
-  const { readDictionaryFile } = await import("../codegen/read-dictionary.js");
-
-  const config = options.config;
-  const entries = resolveNamespaces(config);
-  const namespaces: Record<string, DictionaryJson> = {};
-
-  for (const entry of entries) {
-    const absolutePath = path.resolve(options.projectRoot, entry.filePath);
-    namespaces[entry.namespace] = readDictionaryFile(absolutePath);
-  }
-
-  const report = auditDictionaries({
-    namespaces,
-    config,
-    ...(options.treatEmptyAsMissing !== undefined
-      ? { treatEmptyAsMissing: options.treatEmptyAsMissing }
-      : {}),
-  });
-
-  const exitCode =
-    options.failOn && reportHasGaps(report, options.failOn) ? (1 as const) : (0 as const);
-
-  return { report, exitCode };
-}