@multiplatform.one/i18n 6.1.0 → 6.3.0

package/tests/frappeBackend.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-// Test 2 & 3: Frappe backend plugin fetches/parses translations and handles errors
-describe("frappeBackend", () => {
-  it("fetches and parses Frappe translations correctly", async () => {
-    // We need to test the backend in a "Frappe enabled" context.
-    // Since VITE_FRAPPE_ENABLED is a build-time constant, we test the
-    // underlying fetch logic directly by importing the module.
-    const mockTranslations = { Save: "Guardar", Delete: "Eliminar", Filters: "Filtros" };
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({ message: mockTranslations }),
-    });
-
-    // Import the backend module — in tests VITE_FRAPPE_ENABLED=false so
-    // createFrappeBackend() returns null. We test the read logic by calling
-    // the internal fetchTranslations function pattern directly.
-    // Instead, we simulate the backend's read() behavior:
-    const url = `/api/method/frappe.translate.get_dict?language=es`;
-    const res = await mockFetch(url, { credentials: "include" });
-    const data = await res.json();
-
-    expect(mockFetch).toHaveBeenCalledWith(url, { credentials: "include" });
-    expect(data.message).toEqual(mockTranslations);
-    expect(data.message.Save).toBe("Guardar");
-    expect(data.message.Filters).toBe("Filtros");
-  });
-
-  it("handles fetch failure gracefully", async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 500,
-    });
-
-    const url = `/api/method/frappe.translate.get_dict?language=es`;
-    const res = await mockFetch(url, { credentials: "include" });
-
-    expect(res.ok).toBe(false);
-    expect(res.status).toBe(500);
-
-    // The backend plugin calls callback(err, null) on failure,
-    // allowing i18next to fall back to bundled local resources.
-    // Verify the error path doesn't throw — it returns a rejected promise
-    // that the plugin catches and passes to i18next's callback.
-    const fetchTranslations = async () => {
-      if (!res.ok) throw new Error(`Frappe translation fetch failed: ${res.status}`);
-    };
-    await expect(fetchTranslations()).rejects.toThrow("Frappe translation fetch failed: 500");
-  });
-
-  it("createFrappeBackend returns null when VITE_FRAPPE_ENABLED is false", async () => {
-    // In the test environment, VITE_FRAPPE_ENABLED is false (set in vitest.config)
-    const { createFrappeBackend } = await import("../src/frappe_backend");
-    const backend = createFrappeBackend();
-    expect(backend).toBeNull();
-  });
-});

package/tests/frappeBackendEnabled.test.ts

@@ -1,111 +0,0 @@
-/**
- * Tests for Frappe backend plugin when VITE_FRAPPE_ENABLED=true.
- * This file uses a separate vitest project config that sets the flag to true.
- */
-import { describe, expect, it, vi } from "vitest";
-import type { BackendModule, ReadCallback } from "i18next";
-
-// We can't change import.meta.env at runtime, so we test the backend's
-// behavior by creating a backend-like object that mirrors the implementation.
-function createTestBackend(mockFetch: typeof globalThis.fetch): BackendModule {
-  let opts: { baseUrl?: string; fetch?: typeof globalThis.fetch } = {};
-  return {
-    type: "backend",
-    init(_services, backendOptions) {
-      opts = backendOptions ?? {};
-    },
-    read(language: string, _namespace: string, callback: ReadCallback) {
-      const base = opts.baseUrl ?? "";
-      const fetchFn = opts.fetch ?? mockFetch;
-      const url = `${base}/api/method/frappe.translate.get_dict?language=${encodeURIComponent(language)}`;
-      fetchFn(url, { credentials: "include" })
-        .then((res) => {
-          if (!res.ok) throw new Error(`Frappe translation fetch failed: ${res.status}`);
-          return res.json();
-        })
-        .then((data: any) => callback(null, data.message ?? {}))
-        .catch((err) => callback(err, null));
-    },
-  };
-}
-
-describe("frappeBackend (enabled)", () => {
-  it("read() fetches translations and passes them to callback", async () => {
-    const mockTranslations = { Save: "Guardar", Delete: "Eliminar" };
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({ message: mockTranslations }),
-    }) as unknown as typeof globalThis.fetch;
-
-    const backend = createTestBackend(mockFetch);
-    backend.init({} as any, { fetch: mockFetch }, {} as any);
-
-    const result = await new Promise<Record<string, string>>((resolve, reject) => {
-      backend.read("es", "translation", (err, data) => {
-        if (err) reject(err);
-        else resolve(data as Record<string, string>);
-      });
-    });
-
-    expect(result).toEqual(mockTranslations);
-    expect(mockFetch).toHaveBeenCalledWith("/api/method/frappe.translate.get_dict?language=es", {
-      credentials: "include",
-    });
-  });
-
-  it("read() calls callback with error on fetch failure", async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 503,
-    }) as unknown as typeof globalThis.fetch;
-
-    const backend = createTestBackend(mockFetch);
-    backend.init({} as any, { fetch: mockFetch }, {} as any);
-
-    const error = await new Promise<Error>((resolve) => {
-      backend.read("es", "translation", (err) => {
-        resolve(err as Error);
-      });
-    });
-
-    expect(error).toBeInstanceOf(Error);
-    expect(error.message).toContain("503");
-  });
-
-  it("read() handles network errors gracefully", async () => {
-    const mockFetch = vi
-      .fn()
-      .mockRejectedValue(new TypeError("Failed to fetch")) as unknown as typeof globalThis.fetch;
-
-    const backend = createTestBackend(mockFetch);
-    backend.init({} as any, { fetch: mockFetch }, {} as any);
-
-    const error = await new Promise<Error>((resolve) => {
-      backend.read("es", "translation", (err) => {
-        resolve(err as Error);
-      });
-    });
-
-    expect(error).toBeInstanceOf(TypeError);
-    expect(error.message).toBe("Failed to fetch");
-  });
-
-  it("read() uses custom baseUrl", async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({ message: {} }),
-    }) as unknown as typeof globalThis.fetch;
-
-    const backend = createTestBackend(mockFetch);
-    backend.init({} as any, { baseUrl: "https://frappe.example.com", fetch: mockFetch }, {} as any);
-
-    await new Promise<void>((resolve) => {
-      backend.read("de", "translation", () => resolve());
-    });
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      "https://frappe.example.com/api/method/frappe.translate.get_dict?language=de",
-      { credentials: "include" },
-    );
-  });
-});

package/tests/integrationFrappeDisabled.test.ts

@@ -1,182 +0,0 @@
-/**
- * 10.2 Cross-group integration test: Frappe-disabled flow
- *
- * Simulates booting the i18n system with VITE_FRAPPE_ENABLED=false:
- *  - Only local JSON translations are used
- *  - No Frappe API calls for translations
- *  - frappe-ui strings render from local fallback
- */
-import { describe, it, expect, vi } from "vitest";
-import i18next from "i18next";
-import { createI18nConfig } from "../src/createI18nConfig";
-import { createFrappeBackend } from "../src/frappeBackend";
-import enCommon from "../../../packages/i18n/en/common.json";
-import teCommon from "../../../packages/i18n/te/common.json";
-
-describe("10.2 Frappe-disabled integration flow", () => {
-  it("createFrappeBackend returns null when VITE_FRAPPE_ENABLED is false", () => {
-    // In the test environment, VITE_FRAPPE_ENABLED defaults to "false"
-    const backend = createFrappeBackend();
-    expect(backend).toBeNull();
-  });
-
-  it("createI18nConfig excludes backend when Frappe is disabled", () => {
-    const backend = createFrappeBackend(); // null
-    const config = createI18nConfig({
-      languages: ["en", "te"],
-      namespaces: ["common"],
-      defaultLanguage: "en",
-      defaultNamespace: "common",
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      frappeBackend: backend,
-    });
-
-    // No backend attached
-    expect(config.backend).toBeUndefined();
-    expect(config.partialBundledLanguages).toBeUndefined();
-    // Resources are present
-    expect(config.resources).toBeDefined();
-  });
-
-  it("boots with Telugu using only local JSON translations (no Frappe API calls)", async () => {
-    // Spy on global fetch to ensure no calls are made
-    const fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(() => {
-      throw new Error("fetch should not be called when Frappe is disabled");
-    });
-
-    const instance = i18next.createInstance();
-    const config = createI18nConfig({
-      languages: ["en", "te"],
-      namespaces: ["common"],
-      defaultLanguage: "en",
-      defaultNamespace: "common",
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      frappeBackend: createFrappeBackend(), // null when disabled
-    });
-
-    await instance.init({ ...config, lng: "te" });
-
-    // No fetch calls made
-    expect(fetchSpy).not.toHaveBeenCalled();
-
-    // frappe-ui strings render from local Telugu fallback
-    expect(instance.t("Filters")).toBe("ఫిల్టర్‌లు");
-    expect(instance.t("Save")).toBe("సేవ్ చేయండి");
-    expect(instance.t("Delete")).toBe("తొలగించు");
-    expect(instance.t("Cancel")).toBe("రద్దు చేయండి");
-    expect(instance.t("Loading...")).toBe("లోడ్ అవుతోంది...");
-    expect(instance.t("Expand All")).toBe("అన్నీ విస్తరించు");
-    expect(instance.t("Collapse All")).toBe("అన్నీ కుదించు");
-    expect(instance.t("No items found")).toBe("అంశాలు కనుగొనబడలేదు");
-    expect(instance.t("Attachments")).toBe("అటాచ్‌మెంట్లు");
-    expect(instance.t("Tags")).toBe("ట్యాగ్‌లు");
-
-    // Interpolated strings
-    expect(instance.t("Loading {{doctype}}...", { doctype: "Pokemon" })).toBe(
-      "Pokemon లోడ్ అవుతోంది...",
-    );
-    expect(instance.t("{{n}} selected", { n: 3 })).toBe("3 ఎంచుకోబడింది");
-
-    // Namespaced keys from local JSON
-    expect(instance.t("common.appName")).toBe("multiplatform.one");
-    expect(instance.t("screens.pokemon.title")).toBe("పోకీమాన్");
-
-    fetchSpy.mockRestore();
-  });
-
-  it("switching to English resolves identity-mapped strings from local JSON", async () => {
-    const fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(() => {
-      throw new Error("fetch should not be called when Frappe is disabled");
-    });
-
-    const instance = i18next.createInstance();
-    const config = createI18nConfig({
-      languages: ["en", "te"],
-      namespaces: ["common"],
-      defaultLanguage: "en",
-      defaultNamespace: "common",
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      frappeBackend: createFrappeBackend(),
-    });
-
-    await instance.init({ ...config, lng: "en" });
-
-    // English: identity mapping (key === value)
-    expect(instance.t("Filters")).toBe("Filters");
-    expect(instance.t("Save")).toBe("Save");
-    expect(instance.t("Loading {{doctype}}...", { doctype: "Todo" })).toBe("Loading Todo...");
-    expect(instance.t("Add Row")).toBe("Add Row");
-
-    // Switch to Telugu
-    await instance.changeLanguage("te");
-    expect(instance.t("Filters")).toBe("ఫిల్టర్‌లు");
-    expect(instance.t("Save")).toBe("సేవ్ చేయండి");
-
-    // Switch back to English
-    await instance.changeLanguage("en");
-    expect(instance.t("Filters")).toBe("Filters");
-    expect(instance.t("Save")).toBe("Save");
-
-    // No fetch was ever called
-    expect(fetchSpy).not.toHaveBeenCalled();
-
-    fetchSpy.mockRestore();
-  });
-
-  it("all frappe-ui flat English keys resolve in Telugu locale from local fallback", async () => {
-    const instance = i18next.createInstance();
-    await instance.init({
-      lng: "te",
-      defaultNS: "common",
-      ns: ["common"],
-      supportedLngs: ["en", "te"],
-      fallbackLng: "en",
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      interpolation: { escapeValue: false },
-      returnNull: false,
-    });
-
-    // Spot-check a spread of frappe-ui strings across different component groups
-    const expectations: Array<[string, string]> = [
-      // Core views
-      ["Activity", "కార్యకలాపం"],
-      ["Refresh", "రిఫ్రెష్"],
-      ["Count", "లెక్క"],
-      ["Average", "సగటు"],
-      ["No data to display", "ప్రదర్శించడానికి డేటా లేదు"],
-      // Desk components
-      ["Desk", "డెస్క్"],
-      ["Modules", "మాడ్యూల్స్"],
-      ["Recent", "ఇటీవలి"],
-      ["Favorites", "ఇష్టమైనవి"],
-      // Shared components
-      ["Assigned To", "అసైన్ చేయబడింది"],
-      ["Info", "సమాచారం"],
-      ["List", "జాబితా"],
-      ["Report", "రిపోర్ట్"],
-      ["Kanban", "కాన్బన్"],
-      // Feature components
-      ["No attachments", "అటాచ్‌మెంట్లు లేవు"],
-      ["No tags", "ట్యాగ్‌లు లేవు"],
-      ["No activity yet", "ఇంకా కార్యకలాపం లేదు"],
-      ["Add Comment", "వ్యాఖ్య జోడించు"],
-      ["Add Row", "అడ్డు వరుస జోడించు"],
-    ];
-
-    for (const [key, expectedTelugu] of expectations) {
-      expect(instance.t(key), `Key "${key}" should translate to Telugu`).toBe(expectedTelugu);
-    }
-  });
-});

package/tests/integrationFrappeEnabled.test.ts

@@ -1,232 +0,0 @@
-/**
- * 10.1 Cross-group integration test: Frappe-enabled flow
- *
- * Simulates booting the i18n system with a Frappe backend (mocked),
- * switching to a non-English language, and verifying:
- *  - Frappe translations are loaded and override local resources
- *  - frappe-ui strings render in translated language
- *  - DocType metadata labels come back translated (mocked API)
- */
-import { describe, it, expect } from "vitest";
-import i18next from "i18next";
-import type { BackendModule, ReadCallback } from "i18next";
-import enCommon from "../../../packages/i18n/en/common.json";
-import teCommon from "../../../packages/i18n/te/common.json";
-
-// Simulated Frappe Spanish translations (overrides for frappe-ui strings)
-const frappeEsTranslations: Record<string, string> = {
-  Save: "Guardar",
-  Delete: "Eliminar",
-  Cancel: "Cancelar",
-  Filters: "Filtros",
-  "Loading...": "Cargando...",
-  "Saved Filters": "Filtros guardados",
-  Name: "Nombre",
-  "Add Row": "Agregar fila",
-  "Expand All": "Expandir todo",
-  "Collapse All": "Contraer todo",
-  "No items found": "No se encontraron elementos",
-  "Loading {{doctype}}...": "Cargando {{doctype}}...",
-  "Loading {{doctype}} schema...": "Cargando esquema de {{doctype}}...",
-  Activity: "Actividad",
-  Attachments: "Adjuntos",
-  Tags: "Etiquetas",
-  // DocType metadata labels (what Frappe would return for field labels)
-  "Pokemon Name": "Nombre del Pokémon",
-  Species: "Especie",
-  Height: "Altura",
-  Weight: "Peso",
-};
-
-/**
- * Build a mock Frappe backend that returns translations synchronously.
- * i18next BackendModule `read` calls the callback synchronously
- * so translations are available immediately after init.
- */
-function createMockFrappeBackend(
-  mockTranslations: Record<string, Record<string, string>>,
-): BackendModule & { fetchCalls: Array<{ language: string; namespace: string }> } {
-  const fetchCalls: Array<{ language: string; namespace: string }> = [];
-  return {
-    type: "backend",
-    fetchCalls,
-    init() {},
-    read(language: string, namespace: string, callback: ReadCallback) {
-      fetchCalls.push({ language, namespace });
-      const translations = mockTranslations[language];
-      callback(null, translations ?? {});
-    },
-  };
-}
-
-/**
- * Helper to init an i18next instance with a mock Frappe backend.
- * Uses `partialBundledLanguages: true` so the backend is queried
- * for languages NOT included in `resources`. English is always bundled
- * as the fallback.
- */
-async function initWithFrappeBackend(
-  mockBackend: BackendModule,
-  options: {
-    lng: string;
-    bundledResources?: Record<string, Record<string, unknown>>;
-    supportedLngs?: string[];
-  },
-) {
-  const instance = i18next.createInstance();
-  const { lng, bundledResources, supportedLngs = ["en", "es", "te"] } = options;
-
-  await new Promise<void>((resolve, reject) => {
-    instance.use(mockBackend).init(
-      {
-        lng,
-        defaultNS: "common",
-        ns: ["common"],
-        supportedLngs,
-        fallbackLng: "en",
-        // Only bundle English + any explicitly provided resources.
-        // Non-bundled languages (like es) will be fetched from backend.
-        resources: bundledResources ?? {
-          en: { common: enCommon },
-        },
-        partialBundledLanguages: true,
-        interpolation: { escapeValue: false },
-        returnNull: false,
-        returnEmptyString: false,
-      },
-      (err) => {
-        if (err) reject(err);
-        else resolve();
-      },
-    );
-  });
-
-  return instance;
-}
-
-describe("10.1 Frappe-enabled integration flow", () => {
-  it("loads Frappe translations that override local resources for Spanish", async () => {
-    const mockBackend = createMockFrappeBackend({
-      es: frappeEsTranslations,
-    });
-
-    const instance = await initWithFrappeBackend(mockBackend, { lng: "es" });
-
-    // The backend was called to fetch Spanish translations
-    expect(mockBackend.fetchCalls.length).toBeGreaterThanOrEqual(1);
-    expect(mockBackend.fetchCalls.some((c) => c.language === "es")).toBe(true);
-
-    // Frappe translations override local resources
-    expect(instance.t("Save")).toBe("Guardar");
-    expect(instance.t("Filters")).toBe("Filtros");
-    expect(instance.t("Cancel")).toBe("Cancelar");
-    expect(instance.t("Loading...")).toBe("Cargando...");
-    expect(instance.t("Expand All")).toBe("Expandir todo");
-    expect(instance.t("No items found")).toBe("No se encontraron elementos");
-  });
-
-  it("frappe-ui strings with interpolation render in translated language", async () => {
-    const mockBackend = createMockFrappeBackend({
-      es: frappeEsTranslations,
-    });
-
-    const instance = await initWithFrappeBackend(mockBackend, { lng: "es" });
-
-    // Interpolated frappe-ui strings
-    expect(instance.t("Loading {{doctype}}...", { doctype: "Pokemon" })).toBe(
-      "Cargando Pokemon...",
-    );
-    expect(instance.t("Loading {{doctype}} schema...", { doctype: "Pokemon" })).toBe(
-      "Cargando esquema de Pokemon...",
-    );
-  });
-
-  it("DocType metadata labels come back translated from Frappe", async () => {
-    const mockBackend = createMockFrappeBackend({
-      es: frappeEsTranslations,
-    });
-
-    const instance = await initWithFrappeBackend(mockBackend, {
-      lng: "es",
-      supportedLngs: ["en", "es"],
-    });
-
-    // DocType field labels translated by Frappe
-    expect(instance.t("Pokemon Name")).toBe("Nombre del Pokémon");
-    expect(instance.t("Species")).toBe("Especie");
-    expect(instance.t("Height")).toBe("Altura");
-    expect(instance.t("Weight")).toBe("Peso");
-  });
-
-  it("falls back to English local resource when Frappe has no translation for a key", async () => {
-    const mockBackend = createMockFrappeBackend({
-      es: { Save: "Guardar" }, // Only one key translated by Frappe
-    });
-
-    const instance = await initWithFrappeBackend(mockBackend, {
-      lng: "es",
-      supportedLngs: ["en", "es"],
-    });
-
-    // Key from Frappe
-    expect(instance.t("Save")).toBe("Guardar");
-    // Key NOT in Frappe's dict → falls back to English local resource (identity mapping)
-    expect(instance.t("Filters")).toBe("Filters");
-    expect(instance.t("common.appName")).toBe("multiplatform.one");
-  });
-
-  it("switching language triggers a new backend fetch", async () => {
-    const mockBackend = createMockFrappeBackend({
-      es: frappeEsTranslations,
-      te: { Save: "సేవ్ చేయండి", Filters: "ఫిల్టర్‌లు" },
-    });
-
-    // Start in English (bundled), then switch to Spanish (backend)
-    const instance = await initWithFrappeBackend(mockBackend, { lng: "en" });
-
-    // Initially English from bundled resources
-    expect(instance.t("Save")).toBe("Save");
-
-    // Switch to Spanish — triggers backend fetch
-    await instance.changeLanguage("es");
-    expect(instance.t("Save")).toBe("Guardar");
-    expect(mockBackend.fetchCalls.some((c) => c.language === "es")).toBe(true);
-
-    // Switch to Telugu — triggers another backend fetch
-    await instance.changeLanguage("te");
-    expect(instance.t("Save")).toBe("సేవ్ చేయండి");
-    expect(instance.t("Filters")).toBe("ఫిల్టర్‌లు");
-    expect(mockBackend.fetchCalls.some((c) => c.language === "te")).toBe(true);
-  });
-
-  it("bundled languages use local resources; backend only serves non-bundled languages", async () => {
-    // Architecture: en and te are bundled locally. Spanish is not bundled,
-    // so Frappe backend provides it. The backend is NOT called for bundled languages.
-    const mockBackend = createMockFrappeBackend({
-      es: frappeEsTranslations,
-    });
-
-    const instance = await initWithFrappeBackend(mockBackend, {
-      lng: "te",
-      // Telugu is fully bundled — backend should NOT be called for it
-      bundledResources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-    });
-
-    // Backend was NOT called for Telugu (it's bundled)
-    expect(mockBackend.fetchCalls.some((c) => c.language === "te")).toBe(false);
-
-    // Telugu translations come from local bundled resources
-    expect(instance.t("Save")).toBe("సేవ్ చేయండి");
-    expect(instance.t("Filters")).toBe("ఫిల్టర్‌లు");
-    expect(instance.t("Delete")).toBe("తొలగించు");
-
-    // Switch to Spanish (not bundled) — backend provides translations
-    await instance.changeLanguage("es");
-    expect(mockBackend.fetchCalls.some((c) => c.language === "es")).toBe(true);
-    expect(instance.t("Save")).toBe("Guardar");
-    expect(instance.t("Filters")).toBe("Filtros");
-  });
-});