@multiplatform.one/i18n 6.0.0

package/tests/localFallbackDictionaries.test.ts

@@ -0,0 +1,294 @@
+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");
+  });
+});

package/tests/localePersistence.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { getPersistedLanguage, persistLanguage, parseCookieValue } from "../src/localePersistence";
+
+describe("localePersistence", () => {
+  // Test 1: Cookie set/get roundtrip with preferred_language
+  describe("cookie roundtrip", () => {
+    let originalDocument: typeof globalThis.document;
+
+    beforeEach(() => {
+      // Mock document.cookie for Node.js test environment
+      originalDocument = globalThis.document;
+      let cookieStore = "";
+      Object.defineProperty(globalThis, "document", {
+        value: {
+          get cookie() {
+            return cookieStore;
+          },
+          set cookie(val: string) {
+            // Simple cookie store: accumulate cookies separated by '; '
+            const name = val.split("=")[0];
+            const parts = cookieStore.split("; ").filter((c) => !c.startsWith(`${name}=`));
+            parts.push(val.split(";")[0]);
+            cookieStore = parts.filter(Boolean).join("; ");
+          },
+        },
+        writable: true,
+        configurable: true,
+      });
+    });
+
+    afterEach(() => {
+      Object.defineProperty(globalThis, "document", {
+        value: originalDocument,
+        writable: true,
+        configurable: true,
+      });
+    });
+
+    it("persists and reads back a language cookie", () => {
+      expect(getPersistedLanguage()).toBeNull();
+      persistLanguage("es");
+      expect(getPersistedLanguage()).toBe("es");
+      persistLanguage("te");
+      expect(getPersistedLanguage()).toBe("te");
+    });
+  });
+
+  describe("parseCookieValue", () => {
+    it("extracts a named cookie from a header string", () => {
+      const header = "session_id=abc123; preferred_language=fr; theme=dark";
+      expect(parseCookieValue(header, "preferred_language")).toBe("fr");
+      expect(parseCookieValue(header, "session_id")).toBe("abc123");
+      expect(parseCookieValue(header, "theme")).toBe("dark");
+    });
+
+    it("returns null for missing cookie", () => {
+      expect(parseCookieValue("session_id=abc", "preferred_language")).toBeNull();
+      expect(parseCookieValue("", "preferred_language")).toBeNull();
+    });
+
+    it("decodes URI-encoded values", () => {
+      expect(parseCookieValue("preferred_language=zh-CN", "preferred_language")).toBe("zh-CN");
+    });
+  });
+});

package/tests/makeMkFlag.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { execSync } from "node:child_process";
+import path from "node:path";
+
+const rootdir = path.resolve(__dirname, "../../..");
+
+describe("make.mk FRAPPE_APP_EXISTS flag", () => {
+  // Test 1: Verify the Makefile variable detects apps/frappe directory presence
+  it("sets VITE_FRAPPE_ENABLED=true when apps/frappe exists", () => {
+    // Use --eval to print the evaluated variable value
+    const result = execSync(
+      `make -f make.mk rootdir=${rootdir} --eval='print-flag: ; @echo $(VITE_FRAPPE_ENABLED)' print-flag 2>/dev/null`,
+      { cwd: rootdir, encoding: "utf-8", env: { ...process.env, VITE_FRAPPE_ENABLED: undefined } },
+    ).trim();
+    expect(result).toBe("true");
+  });
+
+  it("FRAPPE_APP_EXISTS reflects directory presence", () => {
+    const result = execSync(
+      `make -f make.mk rootdir=${rootdir} --eval='print-flag: ; @echo $(FRAPPE_APP_EXISTS)' print-flag 2>/dev/null`,
+      { cwd: rootdir, encoding: "utf-8" },
+    ).trim();
+    expect(result).toBe("true");
+  });
+});

package/tests/useLanguagePersistence.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+
+// Test 4: useLanguage persists to cookie when language changes
+// We test the integration by verifying that persistLanguage is called
+// when the changeLanguage callback is invoked.
+describe("useLanguage persistence", () => {
+  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("persistLanguage sets the preferred_language cookie", async () => {
+    const { persistLanguage, getPersistedLanguage } = await import("../src/locale_persistence");
+
+    // Before: no cookie
+    expect(getPersistedLanguage()).toBeNull();
+
+    // Simulate what useLanguage does when setLanguage is called
+    persistLanguage("es");
+    expect(getPersistedLanguage()).toBe("es");
+
+    // Change again
+    persistLanguage("de");
+    expect(getPersistedLanguage()).toBe("de");
+  });
+
+  it("cookie string contains correct attributes", async () => {
+    const { persistLanguage } = await import("../src/locale_persistence");
+    // Capture the raw cookie string set on document
+    let lastCookie = "";
+    Object.defineProperty(globalThis, "document", {
+      value: {
+        get cookie() {
+          return cookieStore;
+        },
+        set cookie(val: string) {
+          lastCookie = val;
+        },
+      },
+      writable: true,
+      configurable: true,
+    });
+
+    persistLanguage("fr");
+    expect(lastCookie).toContain("preferred_language=fr");
+    expect(lastCookie).toContain("path=/");
+    expect(lastCookie).toContain("max-age=");
+    expect(lastCookie).toContain("samesite=lax");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "composite": false,
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"],
+  "references": []
+}

package/vitest.config.mjs

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+
+// Ensure VITE_FRAPPE_ENABLED is "false" in test env by default
+process.env.VITE_FRAPPE_ENABLED = "false";
+
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    testTimeout: 10000,
+    include: ["tests/**/*.test.{ts,tsx}", "src/**/*.spec.{ts,tsx}"],
+    exclude: ["**/node_modules/**", "**/dist/**"],
+  },
+});