@jant/core 0.3.35 → 0.3.37

package/src/i18n/__tests__/detect.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import { detectLocaleFromHeader } from "../detect.js";
+
+describe("detectLocaleFromHeader", () => {
+  // English variants
+  it("returns en for en", () => {
+    expect(detectLocaleFromHeader("en")).toBe("en");
+  });
+
+  it("returns en for en-US", () => {
+    expect(detectLocaleFromHeader("en-US")).toBe("en");
+  });
+
+  it("returns en for en-GB", () => {
+    expect(detectLocaleFromHeader("en-GB")).toBe("en");
+  });
+
+  // Simplified Chinese
+  it("maps zh-CN to zh-Hans", () => {
+    expect(detectLocaleFromHeader("zh-CN")).toBe("zh-Hans");
+  });
+
+  it("maps zh-SG to zh-Hans", () => {
+    expect(detectLocaleFromHeader("zh-SG")).toBe("zh-Hans");
+  });
+
+  it("maps zh-Hans to zh-Hans", () => {
+    expect(detectLocaleFromHeader("zh-Hans")).toBe("zh-Hans");
+  });
+
+  // Traditional Chinese
+  it("maps zh-TW to zh-Hant", () => {
+    expect(detectLocaleFromHeader("zh-TW")).toBe("zh-Hant");
+  });
+
+  it("maps zh-HK to zh-Hant", () => {
+    expect(detectLocaleFromHeader("zh-HK")).toBe("zh-Hant");
+  });
+
+  it("maps zh-MO to zh-Hant", () => {
+    expect(detectLocaleFromHeader("zh-MO")).toBe("zh-Hant");
+  });
+
+  it("maps zh-Hant to zh-Hant", () => {
+    expect(detectLocaleFromHeader("zh-Hant")).toBe("zh-Hant");
+  });
+
+  // Bare zh
+  it("maps bare zh to zh-Hans", () => {
+    expect(detectLocaleFromHeader("zh")).toBe("zh-Hans");
+  });
+
+  // q-value priority
+  it("picks highest q-value language", () => {
+    expect(detectLocaleFromHeader("fr;q=0.5,zh-CN;q=0.9,en;q=0.8")).toBe(
+      "zh-Hans",
+    );
+  });
+
+  it("picks first when q-values are equal (stable sort)", () => {
+    expect(detectLocaleFromHeader("zh-TW,en")).toBe("zh-Hant");
+  });
+
+  it("treats missing q as q=1.0", () => {
+    expect(detectLocaleFromHeader("zh-CN,en;q=0.5")).toBe("zh-Hans");
+  });
+
+  // Unsupported languages fallback
+  it("falls back to en for unsupported language", () => {
+    expect(detectLocaleFromHeader("fr")).toBe("en");
+  });
+
+  it("falls back to en when all languages are unsupported", () => {
+    expect(detectLocaleFromHeader("fr,de,ja")).toBe("en");
+  });
+
+  it("returns supported locale when mixed with unsupported", () => {
+    expect(detectLocaleFromHeader("fr,zh-TW;q=0.8")).toBe("zh-Hant");
+  });
+
+  // Edge cases
+  it("returns en for undefined", () => {
+    expect(detectLocaleFromHeader(undefined)).toBe("en");
+  });
+
+  it("returns en for empty string", () => {
+    expect(detectLocaleFromHeader("")).toBe("en");
+  });
+
+  it("returns en for whitespace-only string", () => {
+    expect(detectLocaleFromHeader("   ")).toBe("en");
+  });
+
+  it("skips entries with q=0", () => {
+    expect(detectLocaleFromHeader("zh-CN;q=0,en")).toBe("en");
+  });
+
+  it("handles malformed q-values gracefully (falls back to q=1.0)", () => {
+    expect(detectLocaleFromHeader("zh-CN;q=abc,en")).toBe("zh-Hans");
+  });
+
+  it("is case-insensitive", () => {
+    expect(detectLocaleFromHeader("ZH-CN")).toBe("zh-Hans");
+  });
+
+  it("handles wildcard (*)", () => {
+    expect(detectLocaleFromHeader("*")).toBe("en");
+  });
+
+  it("handles realistic browser header", () => {
+    expect(detectLocaleFromHeader("zh-TW,zh;q=0.9,en-US;q=0.8,en;q=0.7")).toBe(
+      "zh-Hant",
+    );
+  });
+});

package/src/i18n/context.tsx

@@ -63,7 +63,7 @@ export const I18nProvider: FC<I18nProviderProps> = ({ c, children }) => {
  *
  *   return (
  *     <div>
- *       <h1>{_(t({ message: "Dashboard", comment: "@context: Page title" }))}</h1>
+ *       <h1>{_(t({ message: "Settings", comment: "@context: Page title" }))}</h1>
  *     </div>
  *   );
  * }
@@ -72,7 +72,7 @@ export const I18nProvider: FC<I18nProviderProps> = ({ c, children }) => {
  * Or use the i18n instance directly:
  * ```tsx
  * const { i18n } = useLingui();
- * i18n._(t({ message: "Dashboard", comment: "@context: Page title" }))
+ * i18n._(t({ message: "Settings", comment: "@context: Page title" }))
  * ```
  */
 export function useLingui() {

package/src/i18n/detect.ts

@@ -2,7 +2,7 @@
  * Language Detection Utilities
  */
 
-import { locales, isLocale, type Locale } from "./locales.js";
+import { locales, baseLocale, isLocale, type Locale } from "./locales.js";
 
 /**
  * Get display name for a language code
@@ -32,3 +32,87 @@ export function getSupportedLanguages(): Array<{ code: Locale; name: string }> {
 export function isValidLanguage(lang: unknown): lang is Locale {
   return isLocale(lang);
 }
+
+/**
+ * Map a BCP 47 language tag to a supported locale.
+ *
+ * @param tag - BCP 47 language tag (e.g. "zh-CN", "en-US")
+ * @returns Matching locale, or `undefined` if unsupported
+ */
+function mapTagToLocale(tag: string): Locale | undefined {
+  const normalized = tag.trim().toLowerCase();
+  if (!normalized) return undefined;
+
+  // Extract primary language subtag
+  const primary = normalized.split("-")[0];
+
+  // Chinese variants need script/region mapping
+  if (primary === "zh") {
+    const rest = normalized.slice(3); // everything after "zh-"
+    // Simplified Chinese: zh-Hans, zh-CN, zh-SG
+    if (rest === "hans" || rest === "cn" || rest === "sg") return "zh-Hans";
+    // Traditional Chinese: zh-Hant, zh-TW, zh-HK, zh-MO
+    if (rest === "hant" || rest === "tw" || rest === "hk" || rest === "mo")
+      return "zh-Hant";
+    // Bare "zh" defaults to Simplified
+    if (!rest) return "zh-Hans";
+    return undefined;
+  }
+
+  // Direct match (e.g. "en")
+  if (isLocale(primary)) return primary;
+
+  return undefined;
+}
+
+/**
+ * Detect the best supported locale from an `Accept-Language` HTTP header.
+ *
+ * Parses comma-separated entries, respects q-values, and maps BCP 47 tags
+ * to supported locales using script/region rules for Chinese variants.
+ *
+ * @param header - Raw `Accept-Language` header value (e.g. "zh-TW,en;q=0.9")
+ * @returns Best matching locale, or the base locale ("en") if none match
+ *
+ * @example
+ * detectLocaleFromHeader("zh-CN,en;q=0.8") // "zh-Hans"
+ * detectLocaleFromHeader("fr,de;q=0.9")    // "en" (fallback)
+ */
+export function detectLocaleFromHeader(header: string | undefined): Locale {
+  if (!header || !header.trim()) return baseLocale;
+
+  // Parse entries: "lang;q=0.8" → { tag, q }
+  const entries: Array<{ tag: string; q: number }> = [];
+
+  for (const part of header.split(",")) {
+    const segments = part.trim().split(";");
+    const tag = segments[0]?.trim();
+    if (!tag) continue;
+
+    let q = 1.0;
+    for (let i = 1; i < segments.length; i++) {
+      const param = segments[i]?.trim();
+      if (param?.toLowerCase().startsWith("q=")) {
+        const parsed = Number.parseFloat(param.slice(2));
+        if (!Number.isNaN(parsed)) q = parsed;
+        break;
+      }
+    }
+
+    // q=0 means "not acceptable"
+    if (q <= 0) continue;
+
+    entries.push({ tag, q });
+  }
+
+  // Stable sort by q-value descending
+  entries.sort((a, b) => b.q - a.q);
+
+  // Return first matching locale
+  for (const { tag } of entries) {
+    const locale = mapTagToLocale(tag);
+    if (locale) return locale;
+  }
+
+  return baseLocale;
+}

package/src/i18n/i18n.ts

@@ -51,7 +51,7 @@ export function createI18n(locale: Locale): I18n {
  * import { getI18n } from "../i18n/index.js";
  *
  * const i18n = getI18n(c);
- * const title = i18n._(msg({ message: "Dashboard", comment: "@context: Page title" }));
+ * const title = i18n._(msg({ message: "Settings", comment: "@context: Page title" }));
  */
 export function getI18n(c: { get(key: "i18n"): I18n }): I18n {
   return c.get("i18n");

package/src/i18n/index.ts

@@ -24,7 +24,7 @@
  *
  *   return (
  *     <div>
- *       <h1>{t({ message: "Dashboard", comment: "@context: Page title" })}</h1>
+ *       <h1>{t({ message: "Settings", comment: "@context: Page title" })}</h1>
  *       <Trans comment="@context: Help text">
  *         Read the <a href="/docs">documentation</a>
  *       </Trans>
@@ -56,6 +56,7 @@ export {
   isValidLanguage,
   getLanguageDisplayName,
   getSupportedLanguages,
+  detectLocaleFromHeader,
 } from "./detect.js";
 
 // Hono middleware