@multiplatform.one/i18n 6.1.0 → 6.4.0

package/README.md

@@ -0,0 +1,55 @@
+# @multiplatform.one/i18n
+
+Internationalization for multiplatform.one: [i18next](https://www.i18next.com)
+config factory, language detection/persistence, a Frappe translation backend,
+and locale-aware formatters.
+
+## Install
+
+```bash
+pnpm add @multiplatform.one/i18n
+```
+
+Peers: `i18next`, `react` (pair with `react-i18next` in the app).
+
+## What it owns
+
+- **`createI18nConfig(options)`** — builds the i18next config from
+  `languages`, `namespaces`, `defaultLanguage`, `defaultNamespace`, bundled
+  `resources`, and an optional Frappe backend
+- **`createFrappeBackend(options)`** — loads translations from a Frappe server
+- **Language handling** — `useLanguage()`, `detectLanguage()`,
+  `persistLanguage()` / `getPersistedLanguage()` (cookie-based, SSR-safe)
+- **Formatters** — `useFormatDate`, `useFormatNumber`, `useFormatCurrency`
+  (+ non-hook `createDateFormatter`, `createNumberFormatter`,
+  `createCurrencyFormatter`)
+
+## What it must not do
+
+- No UI and no translation _content_ — apps own their resources/namespaces
+
+## Usage
+
+```ts
+import { createI18nConfig } from "@multiplatform.one/i18n";
+import common from "./locales/en/common.json";
+
+export const i18nConfig = createI18nConfig({
+  languages: ["en", "te"],
+  namespaces: ["common"],
+  defaultLanguage: "en",
+  defaultNamespace: "common",
+  resources: { en: { common } },
+});
+```
+
+```tsx
+import { useLanguage, useFormatCurrency } from "@multiplatform.one/i18n";
+
+const [language, setLanguage] = useLanguage();
+const formatCurrency = useFormatCurrency();
+```
+
+## License
+
+Apache-2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/i18n",
-  "version": "6.1.0",
+  "version": "6.4.0",
   "description": "Internationalization utilities and hooks for multiplatform.one",
   "keywords": [
     "i18n",
@@ -10,16 +10,26 @@
   ],
   "license": "Apache-2.0",
   "author": "BitSpur",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/bitspur/frappe/multiplatform.one.git",
+    "directory": "public/i18n"
+  },
   "source": "src/index.ts",
+  "files": [
+    "src",
+    "types",
+    "!types/.tsbuildinfo"
+  ],
   "sideEffects": false,
   "main": "src/index.ts",
   "module": "src/index.ts",
-  "types": "src/index.ts",
+  "types": "types/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "source": "./src/index.ts",
-      "types": "./src/index.ts",
+      "types": "./types/index.d.ts",
       "default": "./src/index.ts"
     }
   },
@@ -27,7 +37,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@multiplatform.one/platform": "6.1.0"
+    "@multiplatform.one/platform": "6.4.0"
   },
   "devDependencies": {
     "@types/react": "~19.2.14",
@@ -40,6 +50,7 @@
     "react": "^19.1.0"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "rm -rf types 2>/dev/null && tsc -p tsconfig.build.json"
   }
 }

package/src/frappeBackend.spec.ts

@@ -0,0 +1,108 @@
+/**
+ * Frappe i18next backend contracts — the VITE_FRAPPE_ENABLED tree-shaking
+ * guard (backend must be null when Frappe is off), and the backend read
+ * path: fetches Frappe's get_dict endpoint with credentials, hands the
+ * translation dict to i18next, and surfaces fetch failures as errors.
+ */
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { Services, InitOptions } from "i18next";
+import { createFrappeBackend, type FrappeBackendOptions } from "./frappeBackend";
+
+const savedFlag = process.env.VITE_FRAPPE_ENABLED;
+
+afterEach(() => {
+  if (savedFlag === undefined) delete process.env.VITE_FRAPPE_ENABLED;
+  else process.env.VITE_FRAPPE_ENABLED = savedFlag;
+});
+
+function enabledBackend() {
+  process.env.VITE_FRAPPE_ENABLED = "true";
+  const backend = createFrappeBackend();
+  expect(backend).not.toBeNull();
+  return backend!;
+}
+
+function initBackend(
+  backend: ReturnType<typeof createFrappeBackend>,
+  options: FrappeBackendOptions,
+) {
+  backend!.init({} as Services, options, {} as InitOptions);
+}
+
+describe("createFrappeBackend gating", () => {
+  it("returns null when VITE_FRAPPE_ENABLED is not 'true' (tree-shake guard)", () => {
+    process.env.VITE_FRAPPE_ENABLED = "false";
+    expect(createFrappeBackend()).toBeNull();
+    delete process.env.VITE_FRAPPE_ENABLED;
+    expect(createFrappeBackend()).toBeNull();
+  });
+
+  it("returns a backend module when enabled", () => {
+    const backend = enabledBackend();
+    expect(backend.type).toBe("backend");
+    expect(typeof backend.read).toBe("function");
+  });
+});
+
+describe("backend read", () => {
+  it("fetches the Frappe translation dict and passes it to the callback", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ message: { Hello: "నమస్కారం" } }),
+    });
+    const backend = enabledBackend();
+    initBackend(backend, { baseUrl: "https://erp.example.com", fetch: fetchMock as never });
+
+    const result = await new Promise((resolve, reject) => {
+      backend.read("te", "common", (err, data) => (err ? reject(err) : resolve(data)));
+    });
+
+    expect(result).toEqual({ Hello: "నమస్కారం" });
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://erp.example.com/api/method/frappe.translate.get_dict?language=te",
+      { credentials: "include" },
+    );
+  });
+
+  it("URI-encodes the language in the request", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ message: {} }),
+    });
+    const backend = enabledBackend();
+    initBackend(backend, { fetch: fetchMock as never });
+
+    await new Promise((resolve) => {
+      backend.read("pt BR", "common", () => resolve(null));
+    });
+
+    expect(String(fetchMock.mock.calls[0][0])).toContain("language=pt%20BR");
+  });
+
+  it("falls back to an empty dict when the response has no message", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({}),
+    });
+    const backend = enabledBackend();
+    initBackend(backend, { fetch: fetchMock as never });
+
+    const result = await new Promise((resolve, reject) => {
+      backend.read("en", "common", (err, data) => (err ? reject(err) : resolve(data)));
+    });
+    expect(result).toEqual({});
+  });
+
+  it("surfaces HTTP failures to the callback as errors", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: false, status: 503 });
+    const backend = enabledBackend();
+    initBackend(backend, { fetch: fetchMock as never });
+
+    const error = await new Promise<Error>((resolve) => {
+      backend.read("en", "common", (err) => resolve(err as Error));
+    });
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toContain("503");
+  });
+});

package/src/localePersistence.spec.ts

@@ -0,0 +1,62 @@
+/**
+ * Locale persistence contracts — the `preferred_language` cookie (Frappe's
+ * convention) round-trip on the client, and the SSR-side cookie-header
+ * parser used to boot i18n with the user's language before hydration.
+ */
+
+import { beforeEach, describe, expect, it } from "vitest";
+import { getPersistedLanguage, parseCookieValue, persistLanguage } from "./localePersistence";
+
+function clearPreferredLanguageCookie() {
+  document.cookie = "preferred_language=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+}
+
+describe("persistLanguage / getPersistedLanguage", () => {
+  beforeEach(() => {
+    clearPreferredLanguageCookie();
+  });
+
+  it("returns null when no language has been persisted", () => {
+    expect(getPersistedLanguage()).toBeNull();
+  });
+
+  it("round-trips the language through the preferred_language cookie", () => {
+    persistLanguage("te");
+    expect(document.cookie).toContain("preferred_language=te");
+    expect(getPersistedLanguage()).toBe("te");
+  });
+
+  it("overwrites a previously persisted language", () => {
+    persistLanguage("en");
+    persistLanguage("hi");
+    expect(getPersistedLanguage()).toBe("hi");
+  });
+});
+
+describe("parseCookieValue (SSR cookie header)", () => {
+  it("extracts the named cookie from a multi-cookie header", () => {
+    const header = "sid=abc123; preferred_language=te; system_user=yes";
+    expect(parseCookieValue(header, "preferred_language")).toBe("te");
+  });
+
+  it("handles leading whitespace after semicolons", () => {
+    expect(parseCookieValue("a=1;  preferred_language=en", "preferred_language")).toBe("en");
+  });
+
+  it("returns null when the cookie is absent", () => {
+    expect(parseCookieValue("sid=abc123", "preferred_language")).toBeNull();
+    expect(parseCookieValue("", "preferred_language")).toBeNull();
+  });
+
+  it("does not match cookies whose name only ends with the requested name", () => {
+    expect(parseCookieValue("not_preferred_language=fr", "preferred_language")).toBeNull();
+  });
+
+  it("decodes URI-encoded values", () => {
+    expect(parseCookieValue("preferred_language=pt%2DBR", "preferred_language")).toBe("pt-BR");
+  });
+
+  it("returns null for an empty value", () => {
+    expect(parseCookieValue("preferred_language=", "preferred_language")).toBeNull();
+  });
+});

package/types/createI18nConfig.d.ts

@@ -0,0 +1,38 @@
+import type { BackendModule, InitOptions } from "i18next";
+/**
+ * Options for creating i18n initialization configuration.
+ * All language/namespace settings must be provided by the consumer,
+ * keeping this utility fully generic and framework-level.
+ */
+export interface I18nConfigOptions {
+    /** Supported language codes (e.g. ["en", "te"]) */
+    languages: readonly string[];
+    /** Translation namespaces (e.g. ["common"]) */
+    namespaces: readonly string[];
+    /** Default/fallback language code */
+    defaultLanguage: string;
+    /** Default namespace used when none is specified in t() calls */
+    defaultNamespace: string;
+    /** Translation resources - can be bundled or loaded dynamically */
+    resources?: InitOptions["resources"];
+    /** Frappe backend plugin instance (from createFrappeBackend) */
+    frappeBackend?: BackendModule | null;
+}
+/**
+ * Creates i18n initialization options with consistent settings.
+ * Use this to ensure all platforms have the same i18n behavior.
+ *
+ * When `VITE_FRAPPE_ENABLED` is true and a `frappeBackend` is provided,
+ * i18next is configured with `partialBundledLanguages` so the Frappe
+ * backend supplements (and overrides) bundled local resources.
+ *
+ * @example
+ * import { createI18nConfig, createFrappeBackend } from "@multiplatform.one/i18n";
+ *
+ * i18n.use(initReactI18next).init(createI18nConfig({
+ *   languages, namespaces, defaultLanguage, defaultNamespace, resources,
+ *   frappeBackend: createFrappeBackend(),
+ * }));
+ */
+export declare function createI18nConfig(options: I18nConfigOptions): InitOptions;
+//# sourceMappingURL=createI18nConfig.d.ts.map

package/types/createI18nConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createI18nConfig.d.ts","sourceRoot":"","sources":["../src/createI18nConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,+CAA+C;IAC/C,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,SAAS,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IACrC,gEAAgE;IAChE,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,CAsCxE"}

package/types/detectLanguage.d.ts

@@ -0,0 +1,10 @@
+export interface DetectLanguageOptions {
+    supportedLanguages: string[];
+    defaultLanguage: string;
+}
+/**
+ * Detect the user's preferred language from a Request.
+ * Priority: preferred_language cookie → Accept-Language header → default.
+ */
+export declare function detectLanguage(request: Request, options: DetectLanguageOptions): string;
+//# sourceMappingURL=detectLanguage.d.ts.map

package/types/detectLanguage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectLanguage.d.ts","sourceRoot":"","sources":["../src/detectLanguage.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAqBvF"}

package/types/formatters.d.ts

@@ -0,0 +1,23 @@
+type DateInput = Date | number | string;
+export declare function createDateFormatter(language: string): {
+    format: (date: DateInput, options?: Intl.DateTimeFormatOptions) => string;
+    relative: (date: DateInput) => string;
+};
+export declare function createNumberFormatter(language: string): {
+    format: (value: number, options?: Intl.NumberFormatOptions) => string;
+};
+export declare function createCurrencyFormatter(language: string): {
+    format: (value: number, currency: string, options?: Omit<Intl.NumberFormatOptions, "style" | "currency">) => string;
+};
+export declare function useFormatDate(): {
+    format: (date: DateInput, options?: Intl.DateTimeFormatOptions) => string;
+    relative: (date: DateInput) => string;
+};
+export declare function useFormatNumber(): {
+    format: (value: number, options?: Intl.NumberFormatOptions) => string;
+};
+export declare function useFormatCurrency(): {
+    format: (value: number, currency: string, options?: Omit<Intl.NumberFormatOptions, "style" | "currency">) => string;
+};
+export {};
+//# sourceMappingURL=formatters.d.ts.map

package/types/formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../src/formatters.ts"],"names":[],"mappings":"AAGA,KAAK,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;AAcxC,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM;mBAEjC,SAAS,YAAY,IAAI,CAAC,qBAAqB;qBAE7C,SAAS;EAE7B;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM;oBAElC,MAAM,YAAY,IAAI,CAAC,mBAAmB;EAG7D;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM;oBAG3C,MAAM,YACH,MAAM,YACN,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,UAAU,CAAC;EAGnE;AAED,wBAAgB,aAAa;mBAvBV,SAAS,YAAY,IAAI,CAAC,qBAAqB;qBAE7C,SAAS;EAwB7B;AAED,wBAAgB,eAAe;oBApBX,MAAM,YAAY,IAAI,CAAC,mBAAmB;EAuB7D;AAED,wBAAgB,iBAAiB;oBAjBpB,MAAM,YACH,MAAM,YACN,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,OAAO,GAAG,UAAU,CAAC;EAkBnE"}

package/types/frappeBackend.d.ts

@@ -0,0 +1,14 @@
+import type { BackendModule } from "i18next";
+export interface FrappeBackendOptions {
+    /** Base URL for Frappe API (default: '') */
+    baseUrl?: string;
+    /** Custom fetch function (for SSR or testing) */
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * i18next backend plugin that fetches translations from Frappe's API.
+ * Guarded by VITE_FRAPPE_ENABLED so it tree-shakes out of non-Frappe builds.
+ */
+declare function createFrappeBackend(): BackendModule<FrappeBackendOptions> | null;
+export { createFrappeBackend };
+//# sourceMappingURL=frappeBackend.d.ts.map

package/types/frappeBackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frappeBackend.d.ts","sourceRoot":"","sources":["../src/frappeBackend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAuC,MAAM,SAAS,CAAC;AAElF,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAoBD;;;GAGG;AACH,iBAAS,mBAAmB,IAAI,aAAa,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAgBzE;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/types/index.d.ts

@@ -0,0 +1,9 @@
+export { createI18nConfig } from "./createI18nConfig";
+export type { I18nConfigOptions } from "./createI18nConfig";
+export { createFrappeBackend } from "./frappeBackend";
+export type { FrappeBackendOptions } from "./frappeBackend";
+export { useLanguage } from "./useLanguage";
+export { getPersistedLanguage, persistLanguage, parseCookieValue } from "./localePersistence";
+export { detectLanguage } from "./detectLanguage";
+export { useFormatDate, useFormatNumber, useFormatCurrency, createDateFormatter, createNumberFormatter, createCurrencyFormatter, } from "./formatters";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EACL,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,cAAc,CAAC"}

package/types/localePersistence.d.ts

@@ -0,0 +1,7 @@
+/** Read the `preferred_language` cookie value (client-side). */
+export declare function getPersistedLanguage(): string | null;
+/** Set the `preferred_language` cookie (client-side, 1-year expiry). */
+export declare function persistLanguage(lang: string): void;
+/** Parse a single cookie value from a cookie header string. */
+export declare function parseCookieValue(cookieHeader: string, name: string): string | null;
+//# sourceMappingURL=localePersistence.d.ts.map

package/types/localePersistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localePersistence.d.ts","sourceRoot":"","sources":["../src/localePersistence.ts"],"names":[],"mappings":"AAKA,gEAAgE;AAChE,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,IAAI,CAEpD;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,+DAA+D;AAC/D,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKlF"}

package/types/useLanguage.d.ts

@@ -0,0 +1,2 @@
+export declare function useLanguage(): [string, (locale: string) => void];
+//# sourceMappingURL=useLanguage.d.ts.map

package/types/useLanguage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLanguage.d.ts","sourceRoot":"","sources":["../src/useLanguage.ts"],"names":[],"mappings":"AAIA,wBAAgB,WAAW,IAAI,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,CAsBhE"}

package/CHANGELOG.md

@@ -1,47 +0,0 @@
-# @multiplatform.one/i18n
-
-## 6.1.0
-
-### Patch Changes
-
-- @multiplatform.one/platform@6.1.0
-
-## 6.0.4
-
-### Patch Changes
-
-- @multiplatform.one/platform@6.0.4
-
-## 6.0.3
-
-### Patch Changes
-
-- @multiplatform.one/platform@6.0.3
-
-## 6.0.2
-
-### Patch Changes
-
-- @multiplatform.one/platform@6.0.2
-
-## 6.0.1
-
-### Patch Changes
-
-- @multiplatform.one/platform@6.0.1
-
-## 6.0.0
-
-### Major Changes
-
-- Unified 6.0.0 release: realign all public `@multiplatform.one/*` packages onto a single, matching version line (changesets `fixed` group). Highlights:
-  - **web3 split** into standalone `@multiplatform.one/connectkit` and `@multiplatform.one/gpg` packages; `web3` now depends on them instead of bundling ConnectKit.
-  - **Sign-In With GPG** screen added to the ConnectKit modal.
-  - **Native workspace web-resolution fix** + platform-split wrappers (rich-text / `TextEditor`, forms `Barcode`) so web-only libraries stay out of the native Hermes bundle.
-
-  From this release on, these packages are versioned together.
-
-### Patch Changes
-
-- Updated dependencies
-  - @multiplatform.one/platform@6.0.0

package/tests/createI18nConfig.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createI18nConfig } from "../src/createI18nConfig";
-import type { BackendModule } from "i18next";
-
-const baseOptions = {
-  languages: ["en", "es"] as const,
-  namespaces: ["common"] as const,
-  defaultLanguage: "en",
-  defaultNamespace: "common",
-  resources: { en: { common: { hello: "Hello" } } },
-};
-
-describe("createI18nConfig", () => {
-  // Test 4: When VITE_FRAPPE_ENABLED is false (default in test env),
-  // the backend is excluded even if frappeBackend is provided.
-  it("excludes backend when VITE_FRAPPE_ENABLED is false", () => {
-    const mockBackend: BackendModule = {
-      type: "backend",
-      init: () => {},
-      read: () => {},
-    };
-
-    const config = createI18nConfig({ ...baseOptions, frappeBackend: mockBackend });
-
-    expect(config.backend).toBeUndefined();
-    expect(config.partialBundledLanguages).toBeUndefined();
-    // Core config is still correct
-    expect(config.fallbackLng).toBe("en");
-    expect(config.supportedLngs).toEqual(["en", "es"]);
-    expect(config.resources).toEqual(baseOptions.resources);
-  });
-
-  it("works without frappeBackend option", () => {
-    const config = createI18nConfig(baseOptions);
-
-    expect(config.backend).toBeUndefined();
-    expect(config.partialBundledLanguages).toBeUndefined();
-    expect(config.defaultNS).toBe("common");
-    expect(config.ns).toEqual(["common"]);
-  });
-
-  it("preserves all standard i18next settings", () => {
-    const config = createI18nConfig(baseOptions);
-
-    expect(config.compatibilityJSON).toBe("v3");
-    expect(config.interpolation?.escapeValue).toBe(false);
-    expect(config.returnNull).toBe(false);
-    expect(config.returnEmptyString).toBe(false);
-    expect(config.debug).toBe(false);
-  });
-
-  it("handles null frappeBackend gracefully", () => {
-    const config = createI18nConfig({ ...baseOptions, frappeBackend: null });
-
-    expect(config.backend).toBeUndefined();
-    expect(config.partialBundledLanguages).toBeUndefined();
-  });
-});

package/tests/detectLanguage.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectLanguage } from "../src/detectLanguage";
-
-const supported = ["en", "es", "te", "fr", "de"];
-const opts = { supportedLanguages: supported, defaultLanguage: "en" };
-
-function makeRequest(headers: Record<string, string> = {}): Request {
-  return new Request("http://localhost:8000/", { headers });
-}
-
-describe("detectLanguage", () => {
-  // Test 2: Prefers cookie over Accept-Language
-  it("prefers preferred_language cookie over Accept-Language header", () => {
-    const req = makeRequest({
-      cookie: "preferred_language=te",
-      "accept-language": "es;q=1.0,fr;q=0.9",
-    });
-    expect(detectLanguage(req, opts)).toBe("te");
-  });
-
-  it("falls back to Accept-Language when no cookie is set", () => {
-    const req = makeRequest({ "accept-language": "es;q=0.9,fr;q=0.8" });
-    expect(detectLanguage(req, opts)).toBe("es");
-  });
-
-  it("falls back to default when no cookie or header matches", () => {
-    const req = makeRequest({});
-    expect(detectLanguage(req, opts)).toBe("en");
-  });
-
-  it("ignores cookie value not in supported languages", () => {
-    const req = makeRequest({
-      cookie: "preferred_language=ja",
-      "accept-language": "fr",
-    });
-    expect(detectLanguage(req, opts)).toBe("fr");
-  });
-
-  // Test 3: Parses Accept-Language quality values correctly
-  describe("Accept-Language quality parsing", () => {
-    it("picks highest quality language", () => {
-      const req = makeRequest({ "accept-language": "fr;q=0.7, de;q=0.9, es;q=0.8" });
-      expect(detectLanguage(req, opts)).toBe("de");
-    });
-
-    it("treats missing q as q=1 (highest priority)", () => {
-      const req = makeRequest({ "accept-language": "te, es;q=0.9" });
-      expect(detectLanguage(req, opts)).toBe("te");
-    });
-
-    it("matches base code when full code is not supported", () => {
-      const req = makeRequest({ "accept-language": "es-MX;q=1.0, fr-FR;q=0.8" });
-      expect(detectLanguage(req, opts)).toBe("es");
-    });
-
-    it("skips wildcard (*) entries", () => {
-      const req = makeRequest({ "accept-language": "*, fr;q=0.5" });
-      expect(detectLanguage(req, opts)).toBe("fr");
-    });
-
-    it("returns default when all Accept-Language entries are unsupported", () => {
-      const req = makeRequest({ "accept-language": "ja;q=1.0, zh;q=0.9" });
-      expect(detectLanguage(req, opts)).toBe("en");
-    });
-  });
-});

package/tests/formatters.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import {
-  createDateFormatter,
-  createNumberFormatter,
-  createCurrencyFormatter,
-} from "../src/formatters";
-
-describe("useFormatDate", () => {
-  afterEach(() => vi.useRealTimers());
-
-  it("formats a date differently for en vs te locale", () => {
-    const date = new Date("2024-03-15T12:00:00Z");
-    const en = createDateFormatter("en");
-    const te = createDateFormatter("te");
-    const enResult = en.format(date);
-    const teResult = te.format(date);
-    expect(enResult).toBeTruthy();
-    expect(teResult).toBeTruthy();
-    expect(enResult).not.toBe(teResult);
-  });
-
-  it('relative time returns correct unit ("2 hours ago", "yesterday")', () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2024-06-15T12:00:00Z"));
-    const fmt = createDateFormatter("en");
-    expect(fmt.relative(new Date("2024-06-15T10:00:00Z"))).toBe("2 hours ago");
-    expect(fmt.relative(new Date("2024-06-14T12:00:00Z"))).toBe("yesterday");
-  });
-});
-
-describe("useFormatNumber", () => {
-  it("uses locale-appropriate decimal separator", () => {
-    const en = createNumberFormatter("en");
-    const de = createNumberFormatter("de");
-    expect(en.format(1234.56)).toContain(".");
-    expect(de.format(1234.56)).toContain(",");
-  });
-});
-
-describe("useFormatCurrency", () => {
-  it("formats with correct currency symbol and position", () => {
-    const en = createCurrencyFormatter("en-US");
-    const de = createCurrencyFormatter("de-DE");
-    const usd = en.format(42.5, "USD");
-    const eur = de.format(42.5, "EUR");
-    expect(usd).toMatch(/^\$42\.50$/);
-    expect(eur).toContain("€");
-    expect(eur).toContain("42,50");
-  });
-});