@lovalingo/lovalingo 0.5.27 → 0.5.28

package/dist/__tests__/languageFlags.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/languageFlags.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { countryCodeToFlagEmoji, normalizeLocaleCode, parseLocale, resolveLocaleFlag } from "../utils/languageFlags";
+describe("languageFlags", () => {
+    it("normalizes locale codes with case and underscore variants", () => {
+        expect(normalizeLocaleCode("TR")).toBe("tr");
+        expect(normalizeLocaleCode("tr_TR")).toBe("tr-tr");
+        expect(normalizeLocaleCode("tr-TR")).toBe("tr-tr");
+    });
+    it("parses language and region", () => {
+        expect(parseLocale("en-CA")).toEqual({ language: "en", region: "CA" });
+        expect(parseLocale("fr")).toEqual({ language: "fr", region: null });
+    });
+    it("returns consistent flag for TR variants", () => {
+        expect(resolveLocaleFlag("TR")).toBe("🇹🇷");
+        expect(resolveLocaleFlag("tr")).toBe("🇹🇷");
+        expect(resolveLocaleFlag("tr-TR")).toBe("🇹🇷");
+        expect(resolveLocaleFlag("tr_TR")).toBe("🇹🇷");
+    });
+    it("uses region flag when locale includes region", () => {
+        expect(resolveLocaleFlag("en-CA")).toBe("🇨🇦");
+        expect(resolveLocaleFlag("pt-BR")).toBe("🇧🇷");
+    });
+    it("uses language default region when locale has no region", () => {
+        expect(resolveLocaleFlag("en")).toBe("🇬🇧");
+        expect(resolveLocaleFlag("zh")).toBe("🇨🇳");
+        expect(resolveLocaleFlag("pt")).toBe("🇵🇹");
+    });
+    it("falls back to globe for unknown or invalid locale", () => {
+        expect(resolveLocaleFlag("zzz")).toBe("🌐");
+        expect(resolveLocaleFlag("")).toBe("🌐");
+        expect(resolveLocaleFlag(null)).toBe("🌐");
+    });
+    it("never falls back to white flag", () => {
+        expect(resolveLocaleFlag("zzz")).not.toBe("🏳️");
+        expect(resolveLocaleFlag("foo-bar-baz")).not.toBe("🏳️");
+    });
+    it("converts country code to emoji", () => {
+        expect(countryCodeToFlagEmoji("ca")).toBe("🇨🇦");
+        expect(countryCodeToFlagEmoji("PT")).toBe("🇵🇹");
+        expect(countryCodeToFlagEmoji("ZZZ")).toBeNull();
+    });
+});

package/dist/__tests__/mergeEntitlements.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/mergeEntitlements.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { mergeEntitlementsSeoEnabled } from "../utils/mergeEntitlements";
+describe("mergeEntitlementsSeoEnabled", () => {
+    it("merges seoEnabled when provided", () => {
+        const entitlements = {
+            tier: "starter",
+            maxTargetLocales: 1,
+            allowedTargetLocales: [],
+            brandingRequired: true,
+            hreflangEnabled: false,
+        };
+        const merged = mergeEntitlementsSeoEnabled(entitlements, false);
+        expect(merged?.seoEnabled).toBe(false);
+    });
+    it("returns the same object when seoEnabled is not a boolean", () => {
+        const entitlements = {
+            tier: "startup",
+            maxTargetLocales: 3,
+            allowedTargetLocales: ["zh"],
+            brandingRequired: false,
+            hreflangEnabled: true,
+            seoEnabled: true,
+        };
+        const merged = mergeEntitlementsSeoEnabled(entitlements, null);
+        expect(merged).toBe(entitlements);
+    });
+});

package/dist/components/LanguageSwitcher.js

@@ -1,30 +1,8 @@
-import React, { useState, useEffect, useRef } from 'react';
-const LANGUAGE_FLAGS = {
-    en: '🇬🇧',
-    de: '🇩🇪',
-    fr: '🇫🇷',
-    es: '🇪🇸',
-    it: '🇮🇹',
-    pt: '🇵🇹',
-    nl: '🇳🇱',
-    pl: '🇵🇱',
-    ru: '🇷🇺',
-    hi: '🇮🇳',
-    ja: '🇯🇵',
-    zh: '🇨🇳',
-    ko: '🇰🇷',
-    ar: '🇸🇦',
-    hy: '🇦🇲',
-    tr: '🇹🇷',
-    vi: '🇻🇳',
-    th: '🇹🇭',
-    sv: '🇸🇪',
-    da: '🇩🇰',
-    no: '🇳🇴',
-    fi: '🇫🇮',
-};
+import React, { useState, useEffect, useMemo, useRef } from 'react';
+import { normalizeLocaleCode, resolveLocaleFlag } from '../utils/languageFlags';
 export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, position = 'bottom-right', offsetY = 20, theme = 'dark', branding, }) => {
     const [isOpen, setIsOpen] = useState(false);
+    const [isMobile, setIsMobile] = useState(false);
     const containerRef = useRef(null);
     const isRight = position.endsWith('right');
     const isTop = position.startsWith('top');
@@ -56,11 +34,40 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
             tabHoverShadowLeft: '4px 0 16px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.15)',
             panelShadow: '0 8px 24px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.10)',
         };
-    // Order locales: active first, then others
-    const orderedLocales = [
-        currentLocale,
-        ...locales.filter(l => l !== currentLocale)
-    ];
+    // Why: normalize locale codes for comparisons so variants like "tr_TR" and "tr-TR" are treated consistently.
+    const normalizedCurrentLocale = useMemo(() => normalizeLocaleCode(currentLocale), [currentLocale]);
+    // Why: keep active locale first while preserving caller order for the remaining locales.
+    const orderedLocales = useMemo(() => {
+        const seen = new Set();
+        const items = [];
+        const pushLocale = (value) => {
+            const raw = typeof value === 'string' ? value.trim() : '';
+            const normalized = normalizeLocaleCode(raw);
+            if (!raw || !normalized || seen.has(normalized))
+                return;
+            seen.add(normalized);
+            items.push({ raw, normalized });
+        };
+        if (normalizedCurrentLocale) {
+            pushLocale(currentLocale);
+        }
+        for (const locale of locales) {
+            const raw = typeof locale === 'string' ? locale.trim() : '';
+            const normalized = normalizeLocaleCode(raw);
+            if (!normalized || normalized === normalizedCurrentLocale)
+                continue;
+            pushLocale(raw);
+        }
+        if (items.length === 0) {
+            for (const locale of locales)
+                pushLocale(locale);
+        }
+        return items;
+    }, [currentLocale, locales, normalizedCurrentLocale]);
+    const tabFlag = useMemo(() => {
+        const fallbackLocale = orderedLocales[0]?.normalized || normalizedCurrentLocale;
+        return resolveLocaleFlag(fallbackLocale);
+    }, [orderedLocales, normalizedCurrentLocale]);
     // Close on outside click
     useEffect(() => {
         const handleClickOutside = (event) => {
@@ -73,6 +80,20 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
             return () => document.removeEventListener('mousedown', handleClickOutside);
         }
     }, [isOpen]);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const query = '(max-width: 640px)';
+        const media = window.matchMedia(query);
+        const update = () => setIsMobile(media.matches);
+        update();
+        if (typeof media.addEventListener === 'function') {
+            media.addEventListener('change', update);
+            return () => media.removeEventListener('change', update);
+        }
+        media.addListener(update);
+        return () => media.removeListener(update);
+    }, []);
     // Handle keyboard navigation
     useEffect(() => {
         const handleKeyDown = (event) => {
@@ -135,9 +156,12 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
         gap: '10px',
         boxShadow: tokens.panelShadow,
         transition: 'opacity 0.25s ease, transform 0.25s ease',
+        width: isMobile ? 'min(320px, calc(100vw - 88px))' : 'auto',
     };
     const localeRowStyles = {
-        display: 'flex',
+        display: isMobile ? 'grid' : 'flex',
+        gridTemplateColumns: isMobile ? 'repeat(5, minmax(0, 1fr))' : undefined,
+        justifyItems: isMobile ? 'center' : undefined,
         gap: '10px',
         padding: '0 2px',
     };
@@ -159,7 +183,7 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
         alignItems: 'center',
         gap: '6px',
     };
-    const flagButtonStyles = (locale) => ({
+    const flagButtonStyles = (isActive) => ({
         // Why: the panel stays mounted for the close animation, so buttons must be non-interactive while hidden.
         pointerEvents: isOpen ? 'auto' : 'none',
         width: '32px',
@@ -169,8 +193,8 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
         alignItems: 'center',
         justifyContent: 'center',
         fontSize: '20px',
-        background: locale === currentLocale ? 'rgba(59, 130, 246, 0.2)' : 'transparent',
-        border: locale === currentLocale ? '2px solid rgb(59, 130, 246)' : '2px solid transparent',
+        background: isActive ? 'rgba(59, 130, 246, 0.2)' : 'transparent',
+        border: isActive ? '2px solid rgb(59, 130, 246)' : '2px solid transparent',
         cursor: 'pointer',
         transition: 'transform 0.15s ease, filter 0.15s ease, background 0.15s ease',
         flexShrink: 0,
@@ -185,26 +209,29 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
                 }, onMouseLeave: (e) => {
                     e.currentTarget.style.background = tokens.surfaceBg;
                     e.currentTarget.style.boxShadow = isRight ? tokens.tabShadowRight : tokens.tabShadowLeft;
-                }, "aria-label": "Open language switcher", "aria-expanded": isOpen }, LANGUAGE_FLAGS[currentLocale] || '🌐'),
+                }, "aria-label": "Open language switcher", "aria-expanded": isOpen }, tabFlag),
             React.createElement("div", { style: panelStyles, role: "toolbar", "aria-label": "Language options" },
-                React.createElement("div", { style: localeRowStyles }, orderedLocales.map((locale) => (React.createElement("button", { key: locale, style: flagButtonStyles(locale), onClick: (e) => {
-                        e.stopPropagation();
-                        if (locale === currentLocale) {
-                            setIsOpen(false);
-                        }
-                        else {
-                            onLocaleChange(locale);
-                            setIsOpen(false);
-                        }
-                    }, onMouseEnter: (e) => {
-                        if (locale !== currentLocale) {
-                            e.currentTarget.style.filter = 'brightness(1.3)';
-                        }
-                        e.currentTarget.style.transform = 'scale(1.1)';
-                    }, onMouseLeave: (e) => {
-                        e.currentTarget.style.filter = 'brightness(1)';
-                        e.currentTarget.style.transform = 'scale(1)';
-                    }, "aria-label": `Switch to ${locale.toUpperCase()}`, title: locale.toUpperCase(), tabIndex: isOpen ? 0 : -1 }, LANGUAGE_FLAGS[locale] || '🏳️')))),
+                React.createElement("div", { style: localeRowStyles }, orderedLocales.map((entry) => {
+                    const isActive = entry.normalized === normalizedCurrentLocale;
+                    return (React.createElement("button", { key: entry.normalized, style: flagButtonStyles(isActive), onClick: (e) => {
+                            e.stopPropagation();
+                            if (isActive) {
+                                setIsOpen(false);
+                            }
+                            else {
+                                onLocaleChange(entry.raw);
+                                setIsOpen(false);
+                            }
+                        }, onMouseEnter: (e) => {
+                            if (!isActive) {
+                                e.currentTarget.style.filter = 'brightness(1.3)';
+                            }
+                            e.currentTarget.style.transform = 'scale(1.1)';
+                        }, onMouseLeave: (e) => {
+                            e.currentTarget.style.filter = 'brightness(1)';
+                            e.currentTarget.style.transform = 'scale(1)';
+                        }, "aria-label": `Switch to ${entry.normalized.toUpperCase()}`, title: entry.normalized.toUpperCase(), tabIndex: isOpen ? 0 : -1 }, resolveLocaleFlag(entry.normalized)));
+                })),
                 (branding?.required || branding?.enabled) && (React.createElement("div", { style: badgeRowStyles, "aria-label": "Lovalingo branding" },
                     React.createElement("a", { href: branding.href || 'https://lovalingo.com', target: "_blank", rel: "noreferrer", style: { ...badgeLinkStyles, pointerEvents: isOpen ? 'auto' : 'none' }, tabIndex: isOpen ? 0 : -1, "aria-label": "Localized by Lovalingo", title: "Localized by Lovalingo" },
                         React.createElement("span", { style: {

package/dist/components/LovalingoProvider.js

@@ -15,6 +15,7 @@ import { useStringMissReporting } from '../hooks/provider/useStringMissReporting
 import { LanguageSwitcher } from './LanguageSwitcher';
 import { readEditParams } from './provider/editModeUtils';
 import { applySeoBundle as applySeoBundleInternal } from './provider/seoUtils';
+import { mergeEntitlementsSeoEnabled } from "../utils/mergeEntitlements";
 import { useEditModeOverlay } from './provider/useEditModeOverlay';
 import { useHistoryNavigationPatch } from './provider/useHistoryNavigationPatch';
 import { detectLocaleFromLocation, setDocumentLocale } from './provider/localeUtils';
@@ -147,8 +148,9 @@ navigateRef, // For path mode routing
             const bootstrap = await apiRef.current.fetchBootstrap(locale, window.location.pathname + window.location.search);
             if (cancelled)
                 return;
-            if (bootstrap?.entitlements)
-                setEntitlements(bootstrap.entitlements);
+            if (bootstrap?.entitlements) {
+                setEntitlements(mergeEntitlementsSeoEnabled(bootstrap.entitlements, bootstrap.seoEnabled));
+            }
             if (bootstrap?.loading_bg_color)
                 setCachedLoadingBgColor(bootstrap.loading_bg_color);
             if (bootstrap?.entitlements?.brandingRequired) {
@@ -188,6 +190,7 @@ navigateRef, // For path mode routing
         enhancedPathConfig,
         mode,
         autoApplyRules,
+        seoProp: seo,
         isSeoActive,
         applySeoBundle,
         setEntitlements,

package/dist/components/provider/__tests__/seoUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/provider/__tests__/seoUtils.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, test } from "vitest";
+import { resolveCanonicalHref } from "../seoUtils";
+describe("resolveCanonicalHref", () => {
+    test("prefers alternates canonical when present", () => {
+        expect(resolveCanonicalHref({ canonical_url: "https://example.com/en" }, { canonical: "https://example.com/fr" })).toBe("https://example.com/fr");
+    });
+    test("falls back to seo.canonical_url", () => {
+        expect(resolveCanonicalHref({ canonical_url: "https://example.com/en" }, null)).toBe("https://example.com/en");
+    });
+    test("returns empty when none", () => {
+        expect(resolveCanonicalHref({}, null)).toBe("");
+    });
+});

package/dist/components/provider/seoUtils.d.ts

@@ -3,3 +3,6 @@ export declare function applySeoBundle(bundle: {
     alternates?: any;
     jsonld?: any;
 } | null, hreflangEnabled: boolean): void;
+export declare function resolveCanonicalHref(seo: Record<string, unknown>, alternates: {
+    canonical?: string;
+} | null | undefined): string;

package/dist/components/provider/seoUtils.js

@@ -66,11 +66,7 @@ export function applySeoBundle(bundle, hreflangEnabled) {
         const twitterImageAlt = getString(seo.twitter_image_alt);
         if (twitterImageAlt)
             setOrCreateMeta({ name: 'twitter:image:alt' }, twitterImageAlt);
-        const canonicalHref = typeof seo.canonical_url === 'string' && seo.canonical_url.trim()
-            ? seo.canonical_url.trim()
-            : typeof alternates.canonical === 'string' && alternates.canonical.trim()
-                ? alternates.canonical.trim()
-                : '';
+        const canonicalHref = resolveCanonicalHref(seo, alternates);
         const languages = alternates.languages && typeof alternates.languages === 'object' ? alternates.languages : {};
         const hasAnyAlternate = Boolean(alternates.xDefault) || Object.values(languages).some(Boolean);
         if (!canonicalHref && !(hreflangEnabled && hasAnyAlternate))
@@ -111,3 +107,12 @@ export function applySeoBundle(bundle, hreflangEnabled) {
         // ignore SEO errors
     }
 }
+export function resolveCanonicalHref(seo, alternates) {
+    const alt = alternates && typeof alternates === "object" ? alternates : null;
+    // Why: when alternates exist, canonical must be self-referencing for the active locale.
+    if (alt && typeof alt.canonical === "string" && alt.canonical.trim())
+        return alt.canonical.trim();
+    if (typeof seo?.canonical_url === "string" && seo.canonical_url.trim())
+        return seo.canonical_url.trim();
+    return "";
+}

package/dist/hooks/provider/useBundleLoading.d.ts

@@ -12,6 +12,7 @@ type UseBundleLoadingOptions = {
     enhancedPathConfig: PathNormalizationConfig;
     mode: "dom" | undefined;
     autoApplyRules: boolean;
+    seoProp: boolean;
     isSeoActive: () => boolean;
     applySeoBundle: (bundle: {
         seo?: Record<string, unknown>;
@@ -24,7 +25,7 @@ type UseBundleLoadingOptions = {
     setCachedLoadingBgColor: (color: string | null | undefined) => void;
     getCachedLoadingBgColor: () => string;
 };
-export declare function useBundleLoading({ apiRef, resolvedApiKey, defaultLocale, routing, allLocales, nonLocalizedPaths, enhancedPathConfig, mode, autoApplyRules, isSeoActive, applySeoBundle, setEntitlements, setBrandingEnabled, setCachedBrandingEnabled, setCachedLoadingBgColor, getCachedLoadingBgColor, }: UseBundleLoadingOptions): {
+export declare function useBundleLoading({ apiRef, resolvedApiKey, defaultLocale, routing, allLocales, nonLocalizedPaths, enhancedPathConfig, mode, autoApplyRules, seoProp, isSeoActive, applySeoBundle, setEntitlements, setBrandingEnabled, setCachedBrandingEnabled, setCachedLoadingBgColor, getCachedLoadingBgColor, }: UseBundleLoadingOptions): {
     isLoading: boolean;
     isNavigatingRef: React.MutableRefObject<boolean>;
     loadData: (targetLocale: string, previousLocale?: string) => Promise<void>;

package/dist/hooks/provider/useBundleLoading.js

@@ -4,10 +4,11 @@ import { errorDebug, logDebug } from "../../utils/logger";
 import { isNonLocalizedPath, stripLocalePrefix } from "../../utils/nonLocalizedPaths";
 import { processPath } from "../../utils/pathNormalizer";
 import { applyActiveTranslations, restoreDom, setActiveTranslations, setMarkerEngineExclusions } from "../../utils/markerEngine";
+import { mergeEntitlementsSeoEnabled } from "../../utils/mergeEntitlements";
 import { useDomRules } from "./useDomRules";
 import { PREHIDE_FAILSAFE_MS, usePrehide } from "./usePrehide";
 const CRITICAL_CACHE_PREFIX = "Lovalingo_critical_v0_3";
-export function useBundleLoading({ apiRef, resolvedApiKey, defaultLocale, routing, allLocales, nonLocalizedPaths, enhancedPathConfig, mode, autoApplyRules, isSeoActive, applySeoBundle, setEntitlements, setBrandingEnabled, setCachedBrandingEnabled, setCachedLoadingBgColor, getCachedLoadingBgColor, }) {
+export function useBundleLoading({ apiRef, resolvedApiKey, defaultLocale, routing, allLocales, nonLocalizedPaths, enhancedPathConfig, mode, autoApplyRules, seoProp, isSeoActive, applySeoBundle, setEntitlements, setBrandingEnabled, setCachedBrandingEnabled, setCachedLoadingBgColor, getCachedLoadingBgColor, }) {
     const [isLoading, setIsLoading] = useState(false);
     const retryTimeoutRef = useRef(null);
     const loadingFailsafeTimeoutRef = useRef(null);
@@ -208,7 +209,8 @@ export function useBundleLoading({ apiRef, resolvedApiKey, defaultLocale, routin
                 revealedViaCachedCritical = true;
             }
             const bootstrap = await apiRef.current.fetchBootstrap(targetLocale, currentPath);
-            const nextEntitlements = bootstrap?.entitlements || apiRef.current.getEntitlements();
+            const entitlementsBase = bootstrap?.entitlements || apiRef.current.getEntitlements();
+            const nextEntitlements = mergeEntitlementsSeoEnabled(entitlementsBase, bootstrap?.seoEnabled);
             if (nextEntitlements)
                 setEntitlements(nextEntitlements);
             if (bootstrap?.loading_bg_color) {
@@ -260,7 +262,17 @@ export function useBundleLoading({ apiRef, resolvedApiKey, defaultLocale, routin
                     : await apiRef.current.fetchDomRules(targetLocale);
                 setAndApplyDomRules(cacheKey, domRules);
             }
-            if (isSeoActive() && bootstrap) {
+            let seoActiveForBootstrap = isSeoActive();
+            if (seoProp === false) {
+                seoActiveForBootstrap = false;
+            }
+            else if (typeof bootstrap?.seoEnabled === "boolean") {
+                seoActiveForBootstrap = bootstrap.seoEnabled !== false;
+            }
+            else if (typeof nextEntitlements?.seoEnabled === "boolean") {
+                seoActiveForBootstrap = nextEntitlements.seoEnabled !== false;
+            }
+            if (seoActiveForBootstrap && bootstrap) {
                 const hreflangEnabled = Boolean((bootstrap.entitlements || nextEntitlements)?.hreflangEnabled);
                 applySeoBundle({ seo: bootstrap.seo, alternates: bootstrap.alternates, jsonld: bootstrap.jsonld }, hreflangEnabled);
             }

package/dist/utils/languageFlags.d.ts

@@ -0,0 +1,7 @@
+export declare function normalizeLocaleCode(locale: unknown): string;
+export declare function parseLocale(locale: unknown): {
+    language: string;
+    region: string | null;
+};
+export declare function countryCodeToFlagEmoji(countryCode: unknown): string | null;
+export declare function resolveLocaleFlag(locale: unknown): string;

package/dist/utils/languageFlags.js

@@ -0,0 +1,90 @@
+const EXACT_LOCALE_FLAG_OVERRIDES = {
+    en: "🇬🇧",
+    ar: "🇸🇦",
+    zh: "🇨🇳",
+    fa: "🇮🇷",
+    he: "🇮🇱",
+};
+const LANGUAGE_DEFAULT_REGION = {
+    ar: "SA",
+    bn: "BD",
+    cs: "CZ",
+    da: "DK",
+    de: "DE",
+    el: "GR",
+    en: "GB",
+    es: "ES",
+    fa: "IR",
+    fi: "FI",
+    fr: "FR",
+    he: "IL",
+    hi: "IN",
+    hu: "HU",
+    hy: "AM",
+    id: "ID",
+    it: "IT",
+    ja: "JP",
+    ko: "KR",
+    nl: "NL",
+    no: "NO",
+    pl: "PL",
+    pt: "PT",
+    ro: "RO",
+    ru: "RU",
+    sk: "SK",
+    sv: "SE",
+    th: "TH",
+    tr: "TR",
+    uk: "UA",
+    vi: "VN",
+    yo: "NG",
+    zh: "CN",
+};
+export function normalizeLocaleCode(locale) {
+    if (typeof locale !== "string")
+        return "";
+    return locale.trim().replace(/_/g, "-").toLowerCase();
+}
+export function parseLocale(locale) {
+    const normalized = normalizeLocaleCode(locale);
+    if (!normalized)
+        return { language: "", region: null };
+    const parts = normalized.split("-").filter(Boolean);
+    const language = parts[0] || "";
+    const regionPart = parts.find((part, index) => index > 0 && /^[a-z]{2}$/.test(part));
+    const region = regionPart ? regionPart.toUpperCase() : null;
+    return { language, region };
+}
+export function countryCodeToFlagEmoji(countryCode) {
+    if (typeof countryCode !== "string")
+        return null;
+    const normalized = countryCode.trim().toUpperCase();
+    if (!/^[A-Z]{2}$/.test(normalized))
+        return null;
+    const first = normalized.charCodeAt(0) + 127397;
+    const second = normalized.charCodeAt(1) + 127397;
+    return String.fromCodePoint(first, second);
+}
+export function resolveLocaleFlag(locale) {
+    const normalized = normalizeLocaleCode(locale);
+    if (!normalized)
+        return "🌐";
+    const exact = EXACT_LOCALE_FLAG_OVERRIDES[normalized];
+    if (exact)
+        return exact;
+    const { language, region } = parseLocale(normalized);
+    if (!language)
+        return "🌐";
+    if (region) {
+        const regionFlag = countryCodeToFlagEmoji(region);
+        if (regionFlag)
+            return regionFlag;
+    }
+    const defaultRegion = LANGUAGE_DEFAULT_REGION[language];
+    if (defaultRegion) {
+        const defaultFlag = countryCodeToFlagEmoji(defaultRegion);
+        if (defaultFlag)
+            return defaultFlag;
+    }
+    return "🌐";
+}

package/dist/utils/mergeEntitlements.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectEntitlements } from "./apiTypes";
+export declare function mergeEntitlementsSeoEnabled(entitlements: ProjectEntitlements | null | undefined, seoEnabled: unknown): ProjectEntitlements | null;

package/dist/utils/mergeEntitlements.js

@@ -0,0 +1,7 @@
+export function mergeEntitlementsSeoEnabled(entitlements, seoEnabled) {
+    if (!entitlements)
+        return null;
+    if (typeof seoEnabled !== "boolean")
+        return entitlements;
+    return { ...entitlements, seoEnabled };
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.5.16";
+export declare const VERSION = "0.5.28";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.5.16";
+export const VERSION = "0.5.28";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovalingo/lovalingo",
-  "version": "0.5.27",
+  "version": "0.5.28",
   "description": "React translation runtime with i18n routing, deterministic bundles + DOM rules, and zero-flash rendering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",