@xndrjs/i18n-react 0.8.1 → 0.8.2-alpha.1

package/src/codegen/react-codegen-config.ts

@@ -1,70 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { z } from "zod";
-
-export const DEFAULT_REACT_BINDINGS_BASENAME = "react-bindings.generated.tsx";
-
-const reactCodegenConfigSchema = z
-  .object({
-    output: z.string().min(1).optional(),
-  })
-  .strict();
-
-export type ReactCodegenConfig = z.infer<typeof reactCodegenConfigSchema>;
-
-export function defaultReactBindingsOutput(instanceOutput: string): string {
-  return path.join(path.dirname(instanceOutput), DEFAULT_REACT_BINDINGS_BASENAME);
-}
-
-/** Loads optional `i18n-react.codegen.json` when present. */
-export function loadReactCodegenConfig(configPath: string): ReactCodegenConfig {
-  if (!fs.existsSync(configPath)) {
-    return {};
-  }
-
-  let raw: unknown;
-  try {
-    raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `[i18n-react Codegen Error] Failed to parse react config JSON (${configPath}): ${message}`
-    );
-  }
-
-  const result = reactCodegenConfigSchema.safeParse(raw);
-  if (!result.success) {
-    const issueLines = result.error.issues.map((issue) => {
-      const issuePath = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-      return `  - ${issuePath}: ${issue.message}`;
-    });
-    throw new Error(
-      ["[i18n-react Codegen Error] Invalid i18n-react.codegen.json:", ...issueLines].join("\n")
-    );
-  }
-
-  return result.data;
-}
-
-export function resolveReactBindingsOutputPath(options: {
-  instanceOutput: string;
-  cliOut?: string;
-  reactConfig?: ReactCodegenConfig;
-}): string {
-  if (options.cliOut !== undefined) {
-    return options.cliOut;
-  }
-  if (options.reactConfig?.output !== undefined) {
-    return options.reactConfig.output;
-  }
-  return defaultReactBindingsOutput(options.instanceOutput);
-}
-
-export function defaultReactConfigPath(i18nConfigPath: string): string {
-  const dir = path.dirname(i18nConfigPath);
-  const base = path.basename(i18nConfigPath, path.extname(i18nConfigPath));
-  if (base === "i18n.codegen") {
-    return path.join(dir, "i18n-react.codegen.json");
-  }
-  return path.join(dir, `${base}.react.codegen.json`);
-}

package/src/codegen/write-file-if-changed.ts

@@ -1,16 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-/** Writes only when content changed — stable mtimes for watchers. */
-export function writeFileIfChanged(absolutePath: string, content: string): boolean {
-  if (fs.existsSync(absolutePath)) {
-    const currentContent = fs.readFileSync(absolutePath, "utf8");
-    if (currentContent === content) {
-      return false;
-    }
-  }
-
-  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
-  fs.writeFileSync(absolutePath, content);
-  return true;
-}

package/src/create-load-coordinator.test.ts

@@ -1,421 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createI18nHandle } from "@xndrjs/i18n";
-import { IcuTranslationProviderMulti } from "@xndrjs/i18n";
-import { createLoadCoordinator } from "./create-load-coordinator.js";
-
-type MultiSchema = {
-  default: {
-    greeting: { en: string; it: string };
-  };
-  billing: {
-    invoice: { en: string; it: string };
-  };
-};
-
-type TestMultiParams = {
-  default: {
-    greeting: never;
-  };
-  billing: {
-    invoice: never;
-  };
-};
-
-const defaultEn = {
-  greeting: { en: "Hello" },
-};
-
-const defaultIt = {
-  greeting: { it: "Ciao" },
-};
-
-function deferred<T>() {
-  let resolve!: (value: T) => void;
-  let reject!: (reason?: unknown) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-
-describe("createLoadCoordinator", () => {
-  it("dedupes in-flight loads for the same key", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const load = vi.fn(() => Promise.resolve("loaded"));
-    const engine = {};
-    const key = { engineRef: engine, partition: "en", namespaces: ["default"] as const };
-
-    coordinator.request({ ...key, load });
-    coordinator.request({ ...key, load });
-
-    expect(load).toHaveBeenCalledTimes(1);
-    expect(coordinator.getEntry(key)).toEqual({ status: "pending" });
-    await expect(coordinator.getPromise()).resolves.toBe("loaded");
-    expect(coordinator.revision).toBe(1);
-    expect(coordinator.getResolvedScope()).toBe("loaded");
-    expect(coordinator.getEntry(key)).toEqual({ status: "resolved", scope: "loaded" });
-  });
-
-  it("skips reload when the same key is already resolved", async () => {
-    const coordinator = createLoadCoordinator<number>();
-    const load = vi.fn(() => Promise.resolve(42));
-    const engine = {};
-    const key = {
-      engineRef: engine,
-      partition: undefined,
-      namespaces: ["default"] as const,
-    };
-
-    coordinator.request({ ...key, load });
-    await coordinator.getPromise();
-
-    coordinator.request({ ...key, load });
-
-    expect(load).toHaveBeenCalledTimes(1);
-    expect(coordinator.revision).toBe(1);
-    await expect(coordinator.getPromise()).resolves.toBe(42);
-    expect(coordinator.getEntry(key)).toEqual({ status: "resolved", scope: 42 });
-  });
-
-  it("ensureSync resolves from tryResolveSync without calling load", () => {
-    const coordinator = createLoadCoordinator<string>();
-    const load = vi.fn(() => Promise.resolve("async"));
-    const tryResolveSync = vi.fn(() => "sync");
-    const engine = {};
-    const key = { engineRef: engine, partition: "en", namespaces: ["default"] as const };
-
-    coordinator.ensureSync({ ...key, load, tryResolveSync });
-
-    expect(tryResolveSync).toHaveBeenCalledTimes(1);
-    expect(load).not.toHaveBeenCalled();
-    expect(coordinator.getEntry(key)).toEqual({ status: "resolved", scope: "sync" });
-  });
-
-  it("ensureSync does nothing when tryResolveSync misses (no async kick)", () => {
-    const coordinator = createLoadCoordinator<string>();
-    const load = vi.fn(() => Promise.resolve("async"));
-    const engine = {};
-    const key = { engineRef: engine, partition: "en", namespaces: ["default"] as const };
-
-    coordinator.ensureSync({ ...key, load, tryResolveSync: () => null });
-
-    expect(load).not.toHaveBeenCalled();
-    expect(coordinator.getEntry(key)).toEqual({ status: "pending" });
-  });
-
-  it("ensureSync without tryResolveSync leaves entry absent", () => {
-    const coordinator = createLoadCoordinator<string>();
-    const load = vi.fn(() => Promise.resolve("async"));
-    const engine = {};
-    const key = { engineRef: engine, partition: "en", namespaces: ["default"] as const };
-
-    coordinator.ensureSync({ ...key, load });
-
-    expect(load).not.toHaveBeenCalled();
-    expect(coordinator.getEntry(key)).toEqual({ status: "pending" });
-  });
-
-  it("resolves synchronously when tryResolveSync returns a scope", () => {
-    const coordinator = createLoadCoordinator<string>();
-    const load = vi.fn(() => Promise.resolve("async"));
-    const tryResolveSync = vi.fn(() => "sync");
-    const engine = {};
-    const key = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["default"] as const,
-    };
-
-    coordinator.request({ ...key, load, tryResolveSync });
-
-    expect(load).not.toHaveBeenCalled();
-    expect(tryResolveSync).toHaveBeenCalledTimes(1);
-    expect(coordinator.getEntry(key)).toEqual({ status: "resolved", scope: "sync" });
-    expect(coordinator.getResolvedScope()).toBe("sync");
-  });
-
-  it("falls back to async load when tryResolveSync returns null", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const load = vi.fn(() => Promise.resolve("async"));
-    const tryResolveSync = vi.fn(() => null);
-    const engine = {};
-    const key = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["default"] as const,
-    };
-
-    coordinator.request({ ...key, load, tryResolveSync });
-
-    expect(coordinator.getEntry(key)).toEqual({ status: "pending" });
-    await expect(coordinator.getPromise()).resolves.toBe("async");
-    expect(load).toHaveBeenCalledTimes(1);
-    expect(coordinator.getEntry(key)).toEqual({ status: "resolved", scope: "async" });
-  });
-
-  it("keeps concurrent namespace loads independent", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const billing = deferred<string>();
-    const user = deferred<string>();
-    const engine = {};
-    const billingKey = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["billing"] as const,
-    };
-    const userKey = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["user"] as const,
-    };
-
-    coordinator.request({ ...billingKey, load: () => billing.promise });
-    const billingPromise = coordinator.getPromise();
-
-    coordinator.request({ ...userKey, load: () => user.promise });
-    const userPromise = coordinator.getPromise();
-
-    expect(coordinator.getEntry(billingKey)).toEqual({ status: "pending" });
-    expect(coordinator.getEntry(userKey)).toEqual({ status: "pending" });
-
-    billing.resolve("billing-scope");
-    user.resolve("user-scope");
-
-    await expect(billingPromise).resolves.toBe("billing-scope");
-    await expect(userPromise).resolves.toBe("user-scope");
-    expect(coordinator.revision).toBe(2);
-    expect(coordinator.getEntry(billingKey)).toEqual({
-      status: "resolved",
-      scope: "billing-scope",
-    });
-    expect(coordinator.getEntry(userKey)).toEqual({
-      status: "resolved",
-      scope: "user-scope",
-    });
-  });
-
-  it("caches distinct partitions without cancelling the earlier one", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const first = deferred<string>();
-    const second = deferred<string>();
-    const engine = {};
-
-    coordinator.request({
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["default"],
-      load: () => first.promise,
-    });
-    const enPromise = coordinator.getPromise();
-
-    coordinator.request({
-      engineRef: engine,
-      partition: "it",
-      namespaces: ["default"],
-      load: () => second.promise,
-    });
-    const itPromise = coordinator.getPromise();
-
-    first.resolve("en-scope");
-    second.resolve("it-scope");
-
-    await expect(enPromise).resolves.toBe("en-scope");
-    await expect(itPromise).resolves.toBe("it-scope");
-    expect(coordinator.revision).toBe(2);
-  });
-
-  it("notifies subscribers when a load resolves", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const pending = deferred<string>();
-    const engine = {};
-    const key = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["default"] as const,
-    };
-    const listener = vi.fn();
-
-    const unsubscribe = coordinator.subscribe(listener);
-    coordinator.request({ ...key, load: () => pending.promise });
-
-    expect(listener).not.toHaveBeenCalled();
-    expect(coordinator.getEntry(key)).toEqual({ status: "pending" });
-
-    pending.resolve("ready");
-    await expect(coordinator.getPromise()).resolves.toBe("ready");
-
-    expect(listener).toHaveBeenCalledTimes(1);
-    expect(coordinator.revision).toBe(1);
-    expect(coordinator.getEntry(key)).toEqual({ status: "resolved", scope: "ready" });
-
-    unsubscribe();
-    const other = deferred<string>();
-    coordinator.request({
-      engineRef: engine,
-      partition: "it",
-      namespaces: ["default"],
-      load: () => other.promise,
-    });
-    other.resolve("other");
-    await vi.waitFor(() => expect(coordinator.revision).toBe(2));
-    expect(listener).toHaveBeenCalledTimes(1);
-  });
-
-  it("logs rejected loads when getPromise is not awaited", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const pending = deferred<string>();
-    const engine = {};
-    const key = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["default"] as const,
-    };
-    const consoleError = vi.spyOn(console, "error").mockImplementation(() => void 0);
-
-    coordinator.ensure({ ...key, load: () => pending.promise });
-
-    pending.reject(new Error("load failed"));
-    await vi.waitFor(() => {
-      expect(coordinator.getEntry(key)).toEqual({ status: "error", error: expect.any(Error) });
-    });
-
-    expect(consoleError).toHaveBeenCalledWith(
-      "[i18n-react] namespace load failed:",
-      expect.any(Error)
-    );
-
-    consoleError.mockRestore();
-  });
-
-  it("keeps an error entry and notifies subscribers on reject", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const pending = deferred<string>();
-    const engine = {};
-    const key = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["default"] as const,
-    };
-    const load = vi.fn(() => pending.promise);
-    const listener = vi.fn();
-    const failure = new Error("load failed");
-
-    coordinator.subscribe(listener);
-    coordinator.request({ ...key, load });
-
-    expect(coordinator.getEntry(key)).toEqual({ status: "pending" });
-
-    pending.reject(failure);
-    await expect(coordinator.getPromise()).rejects.toThrow("load failed");
-
-    expect(listener).toHaveBeenCalledTimes(1);
-    expect(coordinator.revision).toBe(1);
-    expect(coordinator.getEntry(key)).toEqual({ status: "error", error: failure });
-    expect(coordinator.getResolvedScope()).toBeNull();
-
-    // Deduped: settled error entry is not retried until retry().
-    coordinator.request({ ...key, load });
-    expect(load).toHaveBeenCalledTimes(1);
-    expect(coordinator.getEntry(key)).toEqual({ status: "error", error: failure });
-  });
-
-  it("retry() evicts an error entry so the next ensure reloads", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const engine = {};
-    const key = {
-      engineRef: engine,
-      partition: "en",
-      namespaces: ["default"] as const,
-    };
-    const load = vi
-      .fn()
-      .mockImplementationOnce(() => Promise.reject(new Error("fail")))
-      .mockImplementationOnce(() => Promise.resolve("ok"));
-
-    coordinator.request({ ...key, load });
-    await expect(coordinator.getPromise()).rejects.toThrow("fail");
-    expect(coordinator.getEntry(key).status).toBe("error");
-
-    coordinator.retry(key);
-    expect(coordinator.getEntry(key)).toEqual({ status: "pending" });
-
-    coordinator.request({ ...key, load });
-    await expect(coordinator.getPromise()).resolves.toBe("ok");
-    expect(load).toHaveBeenCalledTimes(2);
-    expect(coordinator.getEntry(key)).toEqual({ status: "resolved", scope: "ok" });
-  });
-
-  it("distinguishes different engineRef objects via WeakMap ids", async () => {
-    const coordinator = createLoadCoordinator<string>();
-    const engineA = {};
-    const engineB = {};
-    const loadA = vi.fn(() => Promise.resolve("a"));
-    const loadB = vi.fn(() => Promise.resolve("b"));
-
-    coordinator.request({
-      engineRef: engineA,
-      partition: "en",
-      namespaces: ["default"],
-      load: loadA,
-    });
-    const promiseA = coordinator.getPromise();
-    coordinator.request({
-      engineRef: engineB,
-      partition: "en",
-      namespaces: ["default"],
-      load: loadB,
-    });
-    const promiseB = coordinator.getPromise();
-
-    expect(loadA).toHaveBeenCalledTimes(1);
-    expect(loadB).toHaveBeenCalledTimes(1);
-    await expect(promiseA).resolves.toBe("a");
-    await expect(promiseB).resolves.toBe("b");
-    expect(
-      coordinator.getEntry({ engineRef: engineA, partition: "en", namespaces: ["default"] })
-    ).toEqual({ status: "resolved", scope: "a" });
-    expect(
-      coordinator.getEntry({ engineRef: engineB, partition: "en", namespaces: ["default"] })
-    ).toEqual({ status: "resolved", scope: "b" });
-  });
-
-  it("returns pending for unknown keys without using React use()", () => {
-    const coordinator = createLoadCoordinator<string>();
-    expect(
-      coordinator.getEntry({
-        engineRef: {},
-        partition: "en",
-        namespaces: ["missing"],
-      })
-    ).toEqual({ status: "pending" });
-    expect(coordinator.revision).toBe(0);
-  });
-
-  it("integrates with handle split-by-locale loads", async () => {
-    const defaultLoader = vi.fn(async (locale: string) =>
-      locale === "it" ? defaultIt : defaultEn
-    );
-    const engine = new IcuTranslationProviderMulti<MultiSchema, TestMultiParams>({});
-    const handle = createI18nHandle(engine, {
-      namespaceLoaders: {
-        default: defaultLoader,
-      },
-    });
-    const load = () => handle.load({ namespaces: ["default"], locale: "it" });
-    const coordinator = createLoadCoordinator<Awaited<ReturnType<typeof load>>>();
-    const key = {
-      engineRef: engine,
-      partition: "it",
-      namespaces: ["default"] as const,
-    };
-
-    coordinator.request({ ...key, load });
-
-    const scope = await coordinator.getPromise();
-    expect(defaultLoader).toHaveBeenCalledWith("it", { locale: "it" });
-    expect(scope.t("default", "greeting")).toBe("Ciao");
-    expect(coordinator.revision).toBe(1);
-    expect(coordinator.getEntry(key).status).toBe("resolved");
-  });
-});