@xndrjs/i18n 0.8.0 → 0.8.2-alpha.0

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

@@ -1,169 +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 { dirname } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { parseAuditArgs, runAuditCli } from "./run-audit.js";
-
-const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
-const auditBin = join(packageRoot, "bin/audit.mjs");
-
-describe("parseAuditArgs", () => {
-  it("defaults to report-only mode without --fail-on", () => {
-    expect(parseAuditArgs([])).toEqual({
-      configPath: join(process.cwd(), "i18n/i18n.codegen.json"),
-      outPath: undefined,
-      failOn: undefined,
-      treatEmptyAsMissing: true,
-    });
-  });
-
-  it("parses fail-on and allow-empty", () => {
-    const parsed = parseAuditArgs([
-      "--config",
-      "cfg.json",
-      "--fail-on",
-      "effective",
-      "--allow-empty",
-    ]);
-    expect(parsed.failOn).toBe("effective");
-    expect(parsed.treatEmptyAsMissing).toBe(false);
-    expect(parsed.configPath).toBe(join(process.cwd(), "cfg.json"));
-  });
-});
-
-describe("runAuditCli", () => {
-  let tempDir = "";
-
-  afterEach(() => {
-    if (tempDir) {
-      rmSync(tempDir, { recursive: true, force: true });
-      tempDir = "";
-    }
-  });
-
-  function writeFixture(dictionary: Record<string, Record<string, string>>) {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-audit-"));
-    mkdirSync(join(tempDir, "i18n/translations"), { recursive: true });
-    writeFileSync(join(tempDir, "i18n/translations/default.json"), JSON.stringify(dictionary));
-    writeFileSync(
-      join(tempDir, "i18n/i18n.codegen.json"),
-      JSON.stringify({
-        projectName: "App",
-        namespaces: {
-          default: "translations/default.json",
-        },
-        codegenPath: "generated",
-        localeFallback: {
-          en: null,
-          it: "en",
-        },
-      })
-    );
-  }
-
-  it("exits 0 without --fail-on even when effective gaps exist", async () => {
-    writeFixture({
-      welcome: { en: "Welcome" },
-    });
-
-    const previousCwd = process.cwd();
-    process.chdir(tempDir);
-    try {
-      const exitCode = await runAuditCli(["--config", "i18n/i18n.codegen.json"]);
-      expect(exitCode).toBe(0);
-    } finally {
-      process.chdir(previousCwd);
-    }
-  });
-
-  it("exits 1 with --fail-on effective when effective gaps exist", async () => {
-    writeFixture({
-      login_button: { it: "Accedi" },
-    });
-
-    const previousCwd = process.cwd();
-    process.chdir(tempDir);
-    try {
-      const exitCode = await runAuditCli([
-        "--config",
-        "i18n/i18n.codegen.json",
-        "--fail-on",
-        "effective",
-      ]);
-      expect(exitCode).toBe(1);
-    } finally {
-      process.chdir(previousCwd);
-    }
-  });
-
-  it("writes JSON report to --out", async () => {
-    writeFixture({
-      login_button: { en: "Login", it: "Accedi" },
-    });
-
-    const outPath = join(tempDir, "audit.json");
-    const previousCwd = process.cwd();
-    process.chdir(tempDir);
-    try {
-      const exitCode = await runAuditCli(["--config", "i18n/i18n.codegen.json", "--out", outPath]);
-      expect(exitCode).toBe(0);
-      const report = JSON.parse(readFileSync(outPath, "utf8"));
-      expect(report.requiredLocales).toEqual(["en", "it"]);
-      expect(report.missingEffectiveByLocale.default.en).toEqual([]);
-    } finally {
-      process.chdir(previousCwd);
-    }
-  });
-
-  it("exits 2 with an error message when the config is invalid", async () => {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-audit-"));
-    mkdirSync(join(tempDir, "i18n"), { recursive: true });
-    writeFileSync(
-      join(tempDir, "i18n/i18n.codegen.json"),
-      JSON.stringify({ namespaces: { default: "translations/default.json" } })
-    );
-
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => void 0);
-    const previousCwd = process.cwd();
-    process.chdir(tempDir);
-    try {
-      const exitCode = await runAuditCli(["--config", "i18n/i18n.codegen.json"]);
-      expect(exitCode).toBe(2);
-      expect(String(errorSpy.mock.calls[0]?.[0])).toContain("Invalid i18n.codegen.json");
-    } finally {
-      process.chdir(previousCwd);
-      errorSpy.mockRestore();
-    }
-  });
-
-  it("exits 2 with an error message when --fail-on has an invalid value", async () => {
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => void 0);
-    try {
-      const exitCode = await runAuditCli(["--fail-on", "bogus"]);
-      expect(exitCode).toBe(2);
-      expect(String(errorSpy.mock.calls[0]?.[0])).toContain(
-        "[Audit Error] --fail-on must be one of: effective, direct, any"
-      );
-    } finally {
-      errorSpy.mockRestore();
-    }
-  });
-
-  it("runs through the bin wrapper", () => {
-    writeFixture({
-      login_button: { en: "Login" },
-    });
-
-    const result = spawnSync("node", [auditBin, "--config", "i18n/i18n.codegen.json"], {
-      cwd: tempDir,
-      encoding: "utf8",
-    });
-
-    expect(result.status).toBe(0);
-    const report = JSON.parse(result.stdout);
-    expect(report.requiredLocales).toEqual(["en", "it"]);
-  });
-});

package/src/audit/run-audit.ts

@@ -1,94 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { CodegenConfig } from "../codegen/codegen-config-schema.js";
-import { loadConfig } from "../codegen/config.js";
-import { type FailOnCriterion, runAuditFromConfig } from "./audit-dictionaries.js";
-
-const FAIL_ON_VALUES = new Set<FailOnCriterion>(["effective", "direct", "any"]);
-
-export interface AuditCliOptions {
-  configPath: string;
-  outPath?: string;
-  failOn?: FailOnCriterion;
-  treatEmptyAsMissing: boolean;
-}
-
-export function parseAuditArgs(argv: string[]): AuditCliOptions {
-  const configArgIndex = argv.indexOf("--config");
-  const outArgIndex = argv.indexOf("--out");
-  const failOnArgIndex = argv.indexOf("--fail-on");
-
-  const configPath = path.resolve(
-    process.cwd(),
-    configArgIndex >= 0 ? argv[configArgIndex + 1]! : "i18n/i18n.codegen.json"
-  );
-
-  const outPath =
-    outArgIndex >= 0 ? path.resolve(process.cwd(), argv[outArgIndex + 1]!) : undefined;
-
-  let failOn: FailOnCriterion | undefined;
-  if (failOnArgIndex >= 0) {
-    const value = argv[failOnArgIndex + 1];
-    if (!value || !FAIL_ON_VALUES.has(value as FailOnCriterion)) {
-      throw new Error(`[Audit Error] --fail-on must be one of: effective, direct, any`);
-    }
-    failOn = value as FailOnCriterion;
-  }
-
-  const treatEmptyAsMissing = !argv.includes("--allow-empty");
-
-  return {
-    configPath,
-    treatEmptyAsMissing,
-    ...(outPath !== undefined ? { outPath } : {}),
-    ...(failOn !== undefined ? { failOn } : {}),
-  };
-}
-
-export async function runAuditCli(argv = process.argv.slice(2)): Promise<number> {
-  let options: AuditCliOptions;
-  let config: CodegenConfig;
-
-  try {
-    options = parseAuditArgs(argv);
-
-    if (!fs.existsSync(options.configPath)) {
-      console.error(`[Audit Error] Config file not found: ${options.configPath}`);
-      return 2;
-    }
-
-    config = loadConfig(options.configPath);
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    return 2;
-  }
-
-  const projectRoot = path.dirname(options.configPath);
-
-  const { report, exitCode } = await runAuditFromConfig({
-    projectRoot,
-    config,
-    treatEmptyAsMissing: options.treatEmptyAsMissing,
-    ...(options.failOn !== undefined ? { failOn: options.failOn } : {}),
-  });
-
-  const json = `${JSON.stringify(report, null, 2)}\n`;
-
-  if (options.outPath) {
-    fs.mkdirSync(path.dirname(options.outPath), { recursive: true });
-    fs.writeFileSync(options.outPath, json);
-  } else {
-    process.stdout.write(json);
-  }
-
-  return exitCode;
-}
-
-async function main(): Promise<void> {
-  const exitCode = await runAuditCli();
-  process.exit(exitCode);
-}
-
-if (process.argv[1]?.endsWith("run-audit.ts")) {
-  void main();
-}

package/src/builder-load-registry.ts

@@ -1,39 +0,0 @@
-/** Stable key for a lazy-loaded builder resource (namespace + locale or delivery area). */
-export function formatBuilderResourceKey(namespace: string, partition: string): string {
-  return `${namespace}\0${partition}`;
-}
-
-/** Serialized builder resource: namespace + partition (locale / delivery area). */
-export type BuilderResourceEntry = readonly [namespace: string, partition: string];
-
-/**
- * Dedup cache for lazy-loaded builder resources (`namespace` × partition).
- * A repeated `load()` for the same resource skips the loader (avoids re-fetch / re-merge).
- */
-export class BuilderLoadRegistry {
-  private readonly loaded = new Set<string>();
-
-  has(namespace: string, partition: string): boolean {
-    return this.loaded.has(formatBuilderResourceKey(namespace, partition));
-  }
-
-  mark(namespace: string, partition: string): void {
-    this.loaded.add(formatBuilderResourceKey(namespace, partition));
-  }
-
-  /** Snapshot of loaded resources as `[namespace, partition]` tuples. */
-  entries(): BuilderResourceEntry[] {
-    const out: BuilderResourceEntry[] = [];
-    for (const key of this.loaded) {
-      const sep = key.indexOf("\0");
-      out.push([key.slice(0, sep), key.slice(sep + 1)]);
-    }
-    return out;
-  }
-
-  seed(resources: readonly BuilderResourceEntry[]): void {
-    for (const [namespace, partition] of resources) {
-      this.mark(namespace, partition);
-    }
-  }
-}

package/src/builder-loaders.ts

@@ -1,15 +0,0 @@
-/** Split-by-locale or custom-area loader — partition key is locale or area name. */
-export type PartitionedLoader<T> = (
-  partition: string,
-  context: { locale: string }
-) => Promise<T> | T;
-
-export type NamespaceLoader<T> = PartitionedLoader<T>;
-
-export async function invokeNamespaceLoader<T>(
-  loader: NamespaceLoader<T>,
-  partition: string,
-  context: { locale: string }
-): Promise<T> {
-  return await loader(partition, context);
-}

package/src/builder-types.test.ts

@@ -1,49 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-import { createI18nHandle } from "./builder.js";
-import type { I18nHandle } from "./i18n-handle.js";
-import { IcuTranslationProviderMulti } from "./IcuTranslationProviderMulti.js";
-import type { LocalesForDeliveryArea, LocalesForDeliveryAreaOrAll } from "./builder-types.js";
-import type { PartialMultiDictionary } from "./types.js";
-
-type TypestateSchema = {
-  billing: { invoice_summary: { en: string; it: string } };
-};
-
-type TypestateParams = {
-  billing: { invoice_summary: { count: number } };
-};
-
-describe("builder-types", () => {
-  type ProjectLocale = "en" | "en-US" | "it" | "fr";
-  type DeliveryArea = "eu" | "amer";
-  type Artifacts = {
-    eu: readonly ["en", "it", "fr"];
-    amer: readonly ["en-US"];
-  };
-
-  it("LocalesForDeliveryArea indexes artifact locales", () => {
-    expectTypeOf<LocalesForDeliveryArea<Artifacts, "eu">>().toEqualTypeOf<"en" | "it" | "fr">();
-    expectTypeOf<LocalesForDeliveryArea<Artifacts, "amer">>().toEqualTypeOf<"en-US">();
-  });
-
-  it("LocalesForDeliveryAreaOrAll narrows only when a delivery map is configured", () => {
-    expectTypeOf<
-      LocalesForDeliveryAreaOrAll<ProjectLocale, DeliveryArea, Artifacts, "eu">
-    >().toEqualTypeOf<"en" | "it" | "fr">();
-    expectTypeOf<
-      LocalesForDeliveryAreaOrAll<ProjectLocale, never, Record<string, never>, "eu">
-    >().toEqualTypeOf<ProjectLocale>();
-  });
-});
-
-describe("I18nHandle typestate", () => {
-  it("exposes load / peek / serialize", () => {
-    const engine = new IcuTranslationProviderMulti<TypestateSchema, TypestateParams>({});
-    const handle = createI18nHandle(engine);
-    expectTypeOf(handle).toMatchTypeOf<I18nHandle<TypestateSchema, TypestateParams>>();
-    expectTypeOf(handle.serialize).returns.toEqualTypeOf<{
-      dictionary: PartialMultiDictionary<TypestateSchema>;
-      resources: readonly (readonly [string, string])[];
-    }>();
-  });
-});

package/src/builder-types.ts

@@ -1,24 +0,0 @@
-/** Locales served by a delivery area, from a codegen `DELIVERY_ARTIFACTS`-shaped map. */
-export type LocalesForDeliveryArea<
-  Artifacts extends Record<string, readonly string[]>,
-  Area extends keyof Artifacts & string,
-> = Artifacts[Area][number];
-
-/** Map from delivery area to locale lists; empty when custom delivery is not configured. */
-export type DeliveryArtifactsMap<RequestLocales extends string, DeliveryArea extends string> = [
-  DeliveryArea,
-] extends [never]
-  ? Record<string, never>
-  : Record<DeliveryArea, readonly RequestLocales[]>;
-
-/** When a delivery-area map is configured, resolve partition locales; otherwise keep the full pool. */
-export type LocalesForDeliveryAreaOrAll<
-  RequestLocales extends string,
-  DeliveryArea extends string,
-  DeliveryArtifacts extends DeliveryArtifactsMap<RequestLocales, DeliveryArea>,
-  Area extends string,
-> = [DeliveryArea] extends [never]
-  ? RequestLocales
-  : Area extends DeliveryArea
-    ? DeliveryArtifacts[Area][number]
-    : never;

package/src/builder.test.ts

@@ -1,260 +0,0 @@
-import { describe, expect, expectTypeOf, it, vi } from "vitest";
-import { createI18nHandle } from "./builder.js";
-import { IcuTranslationProviderMulti } from "./IcuTranslationProviderMulti.js";
-
-type MultiSchema = {
-  default: {
-    login_button: { en: string; it: string };
-    welcome: { en: string };
-  };
-  billing: {
-    invoice_summary: { en: string; it: string };
-  };
-};
-
-type TestMultiParams = {
-  default: {
-    login_button: never;
-    welcome: { name: string };
-  };
-  billing: {
-    invoice_summary: { count: number; name: string };
-  };
-};
-
-const billingIt = {
-  invoice_summary: {
-    it: "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}",
-  },
-};
-
-const billingEn = {
-  invoice_summary: {
-    en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-  },
-};
-
-const defaultIt = {
-  login_button: { it: "Accedi" },
-  welcome: { it: "Benvenuto {name}!" },
-};
-
-describe("I18nHandle", () => {
-  it("load() invokes mock loaders, merges into the engine, and returns a bound view", async () => {
-    const billingLoader = vi.fn(async (locale: string) => {
-      return locale === "it" ? billingIt : billingEn;
-    });
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: {
-        billing: billingLoader,
-      },
-    });
-
-    const view = await handle.load({ namespaces: ["billing"], locale: "it" });
-
-    expect(billingLoader).toHaveBeenCalledWith("it", { locale: "it" });
-    expect(view.locale).toBe("it");
-    expect(view.t("billing", "invoice_summary", { count: 2, name: "Ada" })).toBe(
-      "Hai 2 fatture per Ada"
-    );
-  });
-
-  it("loads multiple namespaces in one call", async () => {
-    const billingLoader = vi.fn(async (locale: string) =>
-      locale === "it" ? billingIt : billingEn
-    );
-    const defaultLoader = vi.fn(async () => defaultIt);
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-
-    const view = await createI18nHandle(engine, {
-      namespaceLoaders: {
-        billing: billingLoader,
-        default: defaultLoader,
-      },
-    }).load({ namespaces: ["billing", "default"], locale: "it" });
-
-    expect(billingLoader).toHaveBeenCalledWith("it", { locale: "it" });
-    expect(defaultLoader).toHaveBeenCalledWith("it", { locale: "it" });
-    expect(view.t("default", "login_button")).toBe("Accedi");
-    expect(view.t("billing", "invoice_summary", { count: 1, name: "Bob" })).toBe(
-      "Hai 1 fattura per Bob"
-    );
-  });
-
-  it("accumulates engine data across repeated load() calls on the same handle", async () => {
-    const billingLoader = vi.fn(async (locale: string) =>
-      locale === "it" ? billingIt : billingEn
-    );
-    const defaultLoader = vi.fn(async () => defaultIt);
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: {
-        billing: billingLoader,
-        default: defaultLoader,
-      },
-    });
-
-    const billingView = await handle.load({ namespaces: ["billing"], locale: "it" });
-    const defaultView = await handle.load({ namespaces: ["default"], locale: "it" });
-
-    expect(billingLoader).toHaveBeenCalledTimes(1);
-    expect(defaultLoader).toHaveBeenCalledTimes(1);
-    expect(billingView.t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
-      "Hai 1 fattura per Ada"
-    );
-    expect(defaultView.t("default", "login_button")).toBe("Accedi");
-    expect(engine.getAll().billing?.invoice_summary?.it).toBe(billingIt.invoice_summary.it);
-    expect(engine.getAll().default?.login_button?.it).toBe("Accedi");
-  });
-
-  it("returns a view scoped to namespaces declared at load time", async () => {
-    const billingLoader = vi.fn(async (locale: string) =>
-      locale === "it" ? billingIt : billingEn
-    );
-    const defaultLoader = vi.fn(async () => defaultIt);
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: {
-        billing: billingLoader,
-        default: defaultLoader,
-      },
-    });
-
-    const billingView = await handle.load({ namespaces: ["billing"], locale: "it" });
-    await handle.load({ namespaces: ["default"], locale: "it" });
-
-    expect(billingView.t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
-      "Hai 1 fattura per Ada"
-    );
-    // billingView is typed for the billing namespace only; default is excluded at compile time.
-  });
-
-  it("maps locale to delivery partition via partitionForLocale", async () => {
-    const billingLoader = vi.fn(async (area: string) => {
-      return area === "eu" ? billingIt : billingEn;
-    });
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-
-    const view = await createI18nHandle(engine, {
-      namespaceLoaders: {
-        billing: billingLoader,
-      },
-      partitionForLocale: (locale) => (locale === "it" ? "eu" : "us"),
-    }).load({ namespaces: ["billing"], locale: "it" });
-
-    expect(billingLoader).toHaveBeenCalledWith("eu", { locale: "it" });
-    expect(view.locale).toBe("it");
-    expect(view.t("billing", "invoice_summary", { count: 2, name: "Ada" })).toBe(
-      "Hai 2 fatture per Ada"
-    );
-    expectTypeOf(view.t).toBeCallableWith("billing", "invoice_summary", {
-      count: 2,
-      name: "Ada",
-    });
-  });
-
-  it("loads partitioned namespace loaders with locale", async () => {
-    const billingLoader = vi.fn(async (locale: string) =>
-      locale === "it"
-        ? {
-            invoice_summary: {
-              it: "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}",
-            },
-          }
-        : {
-            invoice_summary: {
-              en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-            },
-          }
-    );
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-
-    const view = await createI18nHandle(engine, {
-      namespaceLoaders: {
-        billing: billingLoader,
-      },
-    }).load({ namespaces: ["billing"], locale: "en" });
-
-    expect(billingLoader).toHaveBeenCalledTimes(1);
-    expect(billingLoader.mock.calls[0]).toEqual(["en", { locale: "en" }]);
-    expect(view.t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
-      "You have 1 invoice for Ada"
-    );
-  });
-
-  it("rejects an empty namespaces array", async () => {
-    const billingLoader = vi.fn(async () => billingEn);
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: {
-        billing: billingLoader,
-      },
-    });
-
-    await expect(
-      handle.load({ namespaces: [] as unknown as ["billing"], locale: "en" })
-    ).rejects.toThrow("load() requires a non-empty namespaces array");
-  });
-
-  it("skips a repeated load for the same namespace partition", async () => {
-    const billingLoader = vi.fn(async (locale: string) =>
-      locale === "it" ? billingIt : billingEn
-    );
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: { billing: billingLoader },
-    });
-
-    await handle.load({ namespaces: ["billing"], locale: "it" });
-    await handle.load({ namespaces: ["billing"], locale: "it" });
-
-    expect(billingLoader).toHaveBeenCalledTimes(1);
-  });
-
-  it("returns a destructuring-safe locale-bound scope from load()", async () => {
-    const billingLoader = vi.fn(async () => billingEn);
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const { t } = await createI18nHandle(engine, {
-      namespaceLoaders: { billing: billingLoader },
-    }).load({ namespaces: ["billing"], locale: "en" });
-
-    expect(t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
-      "You have 1 invoice for Ada"
-    );
-  });
-
-  it("still loads a different partition for the same namespace", async () => {
-    const billingLoader = vi.fn(async (locale: string) =>
-      locale === "it" ? billingIt : billingEn
-    );
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: { billing: billingLoader },
-    });
-
-    await handle.load({ namespaces: ["billing"], locale: "it" });
-    await handle.load({ namespaces: ["billing"], locale: "en" });
-
-    expect(billingLoader).toHaveBeenCalledTimes(2);
-    expect(billingLoader).toHaveBeenNthCalledWith(1, "it", { locale: "it" });
-    expect(billingLoader).toHaveBeenNthCalledWith(2, "en", { locale: "en" });
-  });
-
-  it("peek() returns null until resources are loaded, then a sync scope", async () => {
-    const billingLoader = vi.fn(async () => billingEn);
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: { billing: billingLoader },
-    });
-
-    expect(handle.peek({ namespaces: ["billing"], locale: "en" })).toBeNull();
-
-    await handle.load({ namespaces: ["billing"], locale: "en" });
-    const sync = handle.peek({ namespaces: ["billing"], locale: "en" });
-    expect(sync).not.toBeNull();
-    expect(sync!.t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
-      "You have 1 invoice for Ada"
-    );
-  });
-});

package/src/builder.ts

@@ -1,10 +0,0 @@
-export type { NamespaceLoader, PartitionedLoader } from "./builder-loaders.js";
-export { invokeNamespaceLoader } from "./builder-loaders.js";
-export type {
-  I18nHandle,
-  I18nHandleOptions,
-  LoadNamespacesInput,
-  PartitionForLocale,
-  ScopeForLocale,
-} from "./i18n-handle.js";
-export { createI18nHandle } from "./i18n-handle.js";