@multiplatform.one/i18n 6.1.0 → 6.4.0

package/tests/integrationLanguagePersistence.test.ts

@@ -1,241 +0,0 @@
-/**
- * 10.3 Cross-group integration test: Language persistence roundtrip
- *
- * Verifies end-to-end language persistence:
- *  - Change language → cookie set → simulate reload → same language restored
- *  - Change language → Frappe API receives new language context
- *  - SSR detection → correct language from Accept-Language
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import i18next from "i18next";
-import { persistLanguage, getPersistedLanguage, parseCookieValue } from "../src/localePersistence";
-import { detectLanguage } from "../src/detectLanguage";
-import enCommon from "../../../packages/i18n/en/common.json";
-import teCommon from "../../../packages/i18n/te/common.json";
-
-describe("10.3 Language persistence roundtrip", () => {
-  let cookieStore: string;
-
-  beforeEach(() => {
-    cookieStore = "";
-    Object.defineProperty(globalThis, "document", {
-      value: {
-        get cookie() {
-          return cookieStore;
-        },
-        set cookie(val: string) {
-          const name = val.split("=")[0];
-          const parts = cookieStore.split("; ").filter((c) => c && !c.startsWith(`${name}=`));
-          parts.push(val.split(";")[0]);
-          cookieStore = parts.filter(Boolean).join("; ");
-        },
-      },
-      writable: true,
-      configurable: true,
-    });
-  });
-
-  afterEach(() => {
-    Object.defineProperty(globalThis, "document", {
-      value: undefined,
-      writable: true,
-      configurable: true,
-    });
-  });
-
-  it("change language → cookie set → simulate reload → same language restored", async () => {
-    // Step 1: Initialize i18next with English
-    const instance1 = i18next.createInstance();
-    await instance1.init({
-      lng: "en",
-      defaultNS: "common",
-      ns: ["common"],
-      supportedLngs: ["en", "te"],
-      fallbackLng: "en",
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      interpolation: { escapeValue: false },
-      returnNull: false,
-    });
-
-    expect(instance1.language).toBe("en");
-    expect(instance1.t("Save")).toBe("Save");
-
-    // Step 2: Change language to Telugu and persist (simulates useLanguage.changeLanguage)
-    persistLanguage("te");
-    await instance1.changeLanguage("te");
-
-    expect(instance1.language).toBe("te");
-    expect(instance1.t("Save")).toBe("సేవ్ చేయండి");
-
-    // Verify cookie is set
-    expect(getPersistedLanguage()).toBe("te");
-
-    // Step 3: Simulate "reload" — create a new i18next instance and read persisted language
-    const persistedLang = getPersistedLanguage();
-    expect(persistedLang).toBe("te");
-
-    const instance2 = i18next.createInstance();
-    await instance2.init({
-      lng: persistedLang!, // Use the persisted language
-      defaultNS: "common",
-      ns: ["common"],
-      supportedLngs: ["en", "te"],
-      fallbackLng: "en",
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      interpolation: { escapeValue: false },
-      returnNull: false,
-    });
-
-    // Language is restored from cookie
-    expect(instance2.language).toBe("te");
-    expect(instance2.t("Save")).toBe("సేవ్ చేయండి");
-    expect(instance2.t("Filters")).toBe("ఫిల్టర్‌లు");
-    expect(instance2.t("Delete")).toBe("తొలగించు");
-  });
-
-  it("language change updates cookie that Frappe API can read from request", async () => {
-    // Simulate language change
-    persistLanguage("es");
-    expect(getPersistedLanguage()).toBe("es");
-
-    // The preferred_language cookie is included in HTTP requests (via credentials: "include")
-    // Frappe reads this cookie to determine the user's language preference.
-    // Verify the cookie value is parseable from a simulated request cookie header.
-    const simulatedCookieHeader = `session_id=abc123; ${cookieStore}`;
-    const parsedLang = parseCookieValue(simulatedCookieHeader, "preferred_language");
-    expect(parsedLang).toBe("es");
-
-    // Change language again
-    persistLanguage("te");
-    const updatedCookieHeader = `session_id=abc123; ${cookieStore}`;
-    const updatedLang = parseCookieValue(updatedCookieHeader, "preferred_language");
-    expect(updatedLang).toBe("te");
-  });
-
-  it("SSR detects language from cookie in Request headers", () => {
-    const supported = ["en", "es", "te"];
-    const opts = { supportedLanguages: supported, defaultLanguage: "en" };
-
-    // User previously set Telugu
-    const req = new Request("http://localhost:8000/", {
-      headers: {
-        cookie: "preferred_language=te; session_id=xyz",
-        "accept-language": "en-US,en;q=0.9",
-      },
-    });
-
-    const detected = detectLanguage(req, opts);
-    // Cookie takes precedence over Accept-Language
-    expect(detected).toBe("te");
-  });
-
-  it("SSR falls back to Accept-Language when no cookie is set", () => {
-    const supported = ["en", "es", "te"];
-    const opts = { supportedLanguages: supported, defaultLanguage: "en" };
-
-    const req = new Request("http://localhost:8000/", {
-      headers: {
-        "accept-language": "es-MX;q=1.0, en;q=0.5",
-      },
-    });
-
-    const detected = detectLanguage(req, opts);
-    expect(detected).toBe("es");
-  });
-
-  it("full roundtrip: persist → SSR detect → initialize with correct language", async () => {
-    // Step 1: User changes language on the client
-    persistLanguage("te");
-
-    // Step 2: On next request, SSR reads cookie from the request
-    const simulatedRequest = new Request("http://localhost:8000/", {
-      headers: {
-        cookie: cookieStore,
-        "accept-language": "en-US,en;q=0.9",
-      },
-    });
-
-    const detected = detectLanguage(simulatedRequest, {
-      supportedLanguages: ["en", "te", "es"],
-      defaultLanguage: "en",
-    });
-
-    expect(detected).toBe("te");
-
-    // Step 3: SSR initializes i18next with detected language
-    const instance = i18next.createInstance();
-    await instance.init({
-      lng: detected,
-      defaultNS: "common",
-      ns: ["common"],
-      supportedLngs: ["en", "te"],
-      fallbackLng: "en",
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      interpolation: { escapeValue: false },
-      returnNull: false,
-    });
-
-    // SSR renders in the user's chosen language
-    expect(instance.language).toBe("te");
-    expect(instance.t("Save")).toBe("సేవ్ చేయండి");
-    expect(instance.t("Filters")).toBe("ఫిల్టర్‌లు");
-    expect(instance.t("common.appName")).toBe("multiplatform.one");
-  });
-
-  it("language change triggers Frappe API to receive new language context via cookie", async () => {
-    // Simulate the sequence:
-    // 1. User is in English
-    // 2. User switches to Telugu
-    // 3. Next HTTP request includes preferred_language=te cookie
-    persistLanguage("en");
-    expect(getPersistedLanguage()).toBe("en");
-
-    // Simulate: user clicks "Telugu" in language switcher
-    persistLanguage("te");
-    expect(getPersistedLanguage()).toBe("te");
-
-    // Simulate: next API call includes cookies
-    // The HttpClient sends requests with credentials: "include",
-    // so the preferred_language cookie is automatically included.
-    const mockFetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: () =>
-        Promise.resolve({
-          data: [
-            { name: "Pikachu", species: "పికాచు" }, // Telugu metadata from Frappe
-          ],
-        }),
-    });
-
-    // Simulate an API call that would be made after language change
-    await mockFetch("/api/resource/Pokemon", {
-      credentials: "include",
-      headers: {
-        "Accept-Language": "te",
-        Cookie: cookieStore,
-      },
-    });
-
-    // Verify the API call was made with language context
-    expect(mockFetch).toHaveBeenCalledWith("/api/resource/Pokemon", {
-      credentials: "include",
-      headers: expect.objectContaining({
-        "Accept-Language": "te",
-      }),
-    });
-
-    // The cookie header contains preferred_language=te
-    const callArgs = mockFetch.mock.calls[0][1];
-    const cookieVal = parseCookieValue(callArgs.headers.Cookie, "preferred_language");
-    expect(cookieVal).toBe("te");
-  });
-});

package/tests/integrationTreeshaking.test.ts

@@ -1,126 +0,0 @@
-/**
- * 10.5 Bundle size / tree-shaking verification
- *
- * Verifies that the Frappe backend plugin code is structured to tree-shake
- * out of non-Frappe builds:
- *  - createFrappeBackend is guarded by process.env.VITE_FRAPPE_ENABLED
- *  - When VITE_FRAPPE_ENABLED=false, createFrappeBackend returns null
- *  - createI18nConfig does not attach backend when VITE_FRAPPE_ENABLED=false
- *  - The Frappe API URL telltale string is inside the guarded code path
- *  - The module source structure enables dead-code elimination
- */
-import { describe, it, expect } from "vitest";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { createFrappeBackend } from "../src/frappeBackend";
-import { createI18nConfig } from "../src/createI18nConfig";
-import type { BackendModule } from "i18next";
-
-describe("10.5 Tree-shaking & bundle verification", () => {
-  describe("runtime guards", () => {
-    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 does not attach backend when disabled", () => {
-      const config = createI18nConfig({
-        languages: ["en"],
-        namespaces: ["common"],
-        defaultLanguage: "en",
-        defaultNamespace: "common",
-        resources: { en: { common: {} } },
-        frappeBackend: null,
-      });
-
-      expect(config.backend).toBeUndefined();
-      expect(config.partialBundledLanguages).toBeUndefined();
-    });
-
-    it("createI18nConfig omits backend even when a non-null backend is passed but flag is false", () => {
-      const mockBackend: BackendModule = {
-        type: "backend",
-        init() {},
-        read() {},
-      };
-
-      const config = createI18nConfig({
-        languages: ["en"],
-        namespaces: ["common"],
-        defaultLanguage: "en",
-        defaultNamespace: "common",
-        resources: { en: { common: {} } },
-        frappeBackend: mockBackend,
-      });
-
-      // Even though a backend was provided, it's not attached because VITE_FRAPPE_ENABLED=false
-      expect(config.backend).toBeUndefined();
-    });
-  });
-
-  describe("source code structure enables tree-shaking", () => {
-    it("frappeBackend.ts guards the entire backend creation with VITE_FRAPPE_ENABLED check", () => {
-      const source = readFileSync(resolve(__dirname, "../src/frappeBackend.ts"), "utf-8");
-
-      // The guard must be present — this is what allows bundlers to eliminate the code
-      expect(source).toContain("process.env.VITE_FRAPPE_ENABLED");
-      expect(source).toContain("return null");
-
-      // The Frappe API URL (telltale string) is INSIDE the guarded code path
-      expect(source).toContain("frappe.translate.get_dict");
-
-      // The guard pattern: returns null early when flag is not "true"
-      // This means when the bundler replaces VITE_FRAPPE_ENABLED with "false",
-      // the entire backend object literal becomes dead code.
-      expect(source).toMatch(/VITE_FRAPPE_ENABLED.*!==.*"true".*return null/s);
-    });
-
-    it("createI18nConfig.ts guards backend attachment with VITE_FRAPPE_ENABLED check", () => {
-      const source = readFileSync(resolve(__dirname, "../src/createI18nConfig.ts"), "utf-8");
-
-      // The config conditionally includes backend only when enabled
-      expect(source).toContain("process.env.VITE_FRAPPE_ENABLED");
-      expect(source).toContain("partialBundledLanguages");
-
-      // The guard pattern: if block only executes when VITE_FRAPPE_ENABLED === "true"
-      expect(source).toMatch(/VITE_FRAPPE_ENABLED.*===.*"true".*frappeBackend/s);
-    });
-
-    it("frappeBackend.ts does not have side effects at module level", () => {
-      const source = readFileSync(resolve(__dirname, "../src/frappeBackend.ts"), "utf-8");
-
-      // The fetch function is defined but not called at module level.
-      // Only createFrappeBackend() is exported, and it returns null when disabled.
-      // This ensures Vite/Rollup can tree-shake the entire module.
-      expect(source).not.toMatch(/^fetch\(/m);
-      expect(source).not.toMatch(/^await /m);
-      // The package.json has "sideEffects": false, confirming tree-shaking
-    });
-
-    it("package.json has sideEffects: false for tree-shaking", () => {
-      const pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf-8"));
-      expect(pkg.sideEffects).toBe(false);
-    });
-  });
-
-  describe("export structure", () => {
-    it("index.ts exports createFrappeBackend (tree-shakeable named export)", () => {
-      const source = readFileSync(resolve(__dirname, "../src/index.ts"), "utf-8");
-
-      // Named exports allow tree-shaking — consumers that don't import
-      // createFrappeBackend won't include it in their bundle
-      expect(source).toContain("createFrappeBackend");
-
-      // It's a named re-export, not a default export or namespace import
-      expect(source).toMatch(/export\s*\{.*createFrappeBackend.*\}/s);
-    });
-
-    it("all i18n exports are named (not default) for optimal tree-shaking", () => {
-      const source = readFileSync(resolve(__dirname, "../src/index.ts"), "utf-8");
-
-      // No default export — all named exports are individually tree-shakeable
-      expect(source).not.toContain("export default");
-    });
-  });
-});

package/tests/localFallbackDictionaries.test.ts

@@ -1,294 +0,0 @@
-import { describe, expect, it } from "vitest";
-import i18next from "i18next";
-import enCommon from "../../../packages/i18n/en/common.json";
-import teCommon from "../../../packages/i18n/te/common.json";
-
-/**
- * Complete inventory of flat English string keys used in frappe-ui components
- * (Groups 5-7). Each string is used as its own translation key following
- * Frappe's __() convention.
- */
-const frappeUiStrings = [
-  // FrappeForm
-  "Validation error occurred",
-  "Failed to save document",
-  "Delete this {{doctype}}?",
-  "Failed to delete",
-  "Loading {{doctype}}...",
-  "Loading form...",
-  "Not Saved",
-  "Delete",
-  "Cancel",
-  "Saving...",
-  "Save",
-  "Activity",
-
-  // FrappeListView
-  "Name",
-  "Loading {{doctype}} schema...",
-  "List view",
-  "Table view",
-  "Refresh",
-  "Add {{doctype}}",
-  "Filters",
-  "Saved Filters",
-
-  // FrappeReportBuilder
-  "Count",
-  "Sum",
-  "Average",
-  "Min",
-  "Max",
-  "Bar chart",
-  "Toggle Columns",
-  "Group By:",
-  "None",
-  "Clear group by",
-  "Load",
-  "Saved Reports",
-  "Delete {{name}}",
-  "Columns",
-  "Chart",
-  "Export",
-  "Save Report",
-  "Report name",
-  "Loading data...",
-  "No data to display",
-  "(empty)",
-  "record",
-  "records",
-  "Yes",
-  "No",
-
-  // FrappeTreeView
-  "This DocType does not support tree view",
-  "Loading {{doctype}} tree...",
-  "Updating...",
-  "Expand All",
-  "Collapse All",
-  "No items found",
-
-  // FrappeImageView
-  "No image field configured for {{doctype}}",
-
-  // FrappeCalendar
-  "Today",
-  "Month",
-  "Week",
-  "Day",
-  "Events",
-  "+{{n}} more",
-
-  // FrappeKanban
-  "Drop here",
-  "No items",
-
-  // FrappeDashboard
-  "vs {{previousValue}}",
-  "Loading dashboard...",
-  "Last updated: {{time}}",
-
-  // FrappeList
-  "No {{doctype}} records found",
-  "{{n}} selected",
-  "Select all",
-  "Showing {{n}} items with virtual scrolling",
-
-  // FrappeTable
-  "Error loading {{doctype}}",
-
-  // ViewSwitcher
-  "List",
-  "Table",
-  "Report",
-  "Image",
-  "Tree",
-  "Kanban",
-  "Calendar",
-
-  // FormSidebar
-  "Write",
-  "Read",
-  "Submit",
-  "Share",
-  "Assigned To",
-  "Add assignment",
-  "No assignments",
-  "Attachments",
-  "Tags",
-  "Shared With",
-  "Add share",
-  "Not shared",
-  "Info",
-  "Created by {{owner}} on {{date}}",
-  "Last edited by {{modified_by}} on {{date}}",
-
-  // DeskShell / DeskFormPage / DeskSidebar / DeskListPage
-  "Desk",
-  "No DocType specified",
-  "New",
-  "Modules",
-  "Recent",
-  "Favorites",
-
-  // Awesomebar
-  "Search or type a command (Ctrl+K)",
-  "Result:",
-  "Commands",
-  "Navigation",
-  "Documents",
-  "Searching documents...",
-
-  // FilterManager
-  "Filter name is required",
-  "Failed to save filter",
-  "Save Filter",
-  "Save the current filter configuration for quick access later.",
-  "Filter Name",
-  "e.g., Big Pokemon",
-  "Make this filter global (visible to all users)",
-  "Current filters: {{n}} active",
-
-  // SavedFilterDropdown
-  "(Global)",
-
-  // Attachments
-  "B",
-  "KB",
-  "MB",
-  "GB",
-  "File size exceeds {{limit}} limit",
-  "Failed to read file",
-  "Upload failed",
-  "Delete failed",
-  "No attachments",
-  "Uploading...",
-  "Upload",
-  "Download",
-  "Close",
-
-  // Tags
-  "Add tag...",
-  'Tag "{{name}}" is already applied',
-  "Failed to add tag",
-  "Failed to remove tag",
-  "No tags",
-  'Create "{{value}}"',
-  "Suggestions",
-  "No available tags",
-  "Add Tag",
-  "Click + to add tags",
-
-  // Timeline
-  "just now",
-  "{{count}} minute ago",
-  "{{count}} minutes ago",
-  "{{count}} hour ago",
-  "{{count}} hours ago",
-  "{{count}} day ago",
-  "{{count}} days ago",
-  "{{count}} week ago",
-  "{{count}} weeks ago",
-  "{{count}} month ago",
-  "{{count}} months ago",
-  "No activity yet",
-  "+{{count}} more changes",
-  "made changes",
-  "added an attachment",
-  "assigned",
-  "Add a comment...",
-  "Add Comment",
-  "Sending...",
-  "Comment",
-  "Failed to add comment",
-  "{{count}} entry",
-  "{{count}} entries",
-
-  // ChildTable
-  "#",
-  "Add Row",
-
-  // SchemaForm
-  "Unsupported field type: {{fieldtype}}",
-
-  // Toolbar
-  "Loading...",
-] as const;
-
-describe("Group 8: Local Fallback Dictionaries", () => {
-  it("Test 1: All frappe-ui strings exist as keys in en/common.json", () => {
-    const enKeys = Object.keys(enCommon);
-    const missing: string[] = [];
-
-    for (const str of frappeUiStrings) {
-      if (!enKeys.includes(str)) {
-        missing.push(str);
-      }
-    }
-
-    expect(missing, `Missing keys in en/common.json:\n  ${missing.join("\n  ")}`).toEqual([]);
-
-    // Also verify identity mapping: for English, key === value
-    for (const str of frappeUiStrings) {
-      expect((enCommon as Record<string, unknown>)[str]).toBe(str);
-    }
-  });
-
-  it("Test 2: te/common.json has the same key set as en/common.json", () => {
-    const enKeys = Object.keys(enCommon).sort();
-    const teKeys = Object.keys(teCommon).sort();
-
-    // Every key in en must also appear in te
-    const missingInTe = enKeys.filter((k) => !teKeys.includes(k));
-    expect(
-      missingInTe,
-      `Keys present in en/common.json but missing in te/common.json:\n  ${missingInTe.join("\n  ")}`,
-    ).toEqual([]);
-
-    // Every key in te must also appear in en (no stale keys)
-    const extraInTe = teKeys.filter((k) => !enKeys.includes(k));
-    expect(
-      extraInTe,
-      `Keys present in te/common.json but missing in en/common.json:\n  ${extraInTe.join("\n  ")}`,
-    ).toEqual([]);
-  });
-
-  it('Test 3: t("Filters") resolves correctly in English locale', async () => {
-    const instance = i18next.createInstance();
-    await instance.init({
-      lng: "en",
-      defaultNS: "common",
-      ns: ["common"],
-      resources: {
-        en: { common: enCommon },
-        te: { common: teCommon },
-      },
-      interpolation: { escapeValue: false },
-      returnNull: false,
-    });
-
-    // Flat English string keys resolve via identity mapping
-    expect(instance.t("Filters")).toBe("Filters");
-    expect(instance.t("Save")).toBe("Save");
-    expect(instance.t("Loading...")).toBe("Loading...");
-
-    // Interpolated keys resolve with variable substitution
-    expect(instance.t("Loading {{doctype}}...", { doctype: "Pokemon" })).toBe("Loading Pokemon...");
-    expect(instance.t("{{n}} selected", { n: 5 })).toBe("5 selected");
-
-    // Namespaced keys still work
-    expect(instance.t("common.appName")).toBe("multiplatform.one");
-    expect(instance.t("screens.pokemon.title")).toBe("Pokemon");
-
-    // Switch to Telugu and verify translations differ from English
-    await instance.changeLanguage("te");
-    const teFilters = (teCommon as Record<string, unknown>)["Filters"];
-    const teSave = (teCommon as Record<string, unknown>)["Save"];
-    expect(instance.t("Filters")).toBe(teFilters);
-    expect(instance.t("Save")).toBe(teSave);
-    expect(instance.t("Filters")).not.toBe("Filters");
-    expect(instance.t("Save")).not.toBe("Save");
-    // appName stays the same across locales
-    expect(instance.t("common.appName")).toBe("multiplatform.one");
-  });
-});