@lovalingo/lovalingo 0.5.29 → 0.6.0

package/dist/components/LovalingoProvider.js

@@ -1,413 +0,0 @@
-import React, { useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
-import { LovalingoContext } from '../context/LovalingoContext';
-import { LangRoutingContext } from '../context/LangRoutingContext';
-import { LovalingoAPI } from '../utils/api';
-import { applyActiveTranslations, setMarkerEngineExclusions, startMarkerEngine } from '../utils/markerEngine';
-import { warnDebug } from '../utils/logger';
-import { isNonLocalizedPath, stripLocalePrefix } from '../utils/nonLocalizedPaths';
-import { processPath } from '../utils/pathNormalizer';
-import { useBundleLoading } from '../hooks/provider/useBundleLoading';
-import { useNavigationPrefetch } from '../hooks/provider/useNavigationPrefetch';
-import { useLinkAutoPrefix } from '../hooks/provider/useLinkAutoPrefix';
-import { usePageviewTracking } from '../hooks/provider/usePageviewTracking';
-import { useSitemapLinkTag } from '../hooks/provider/useSitemapLinkTag';
-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';
-import { useProviderCache } from './provider/useProviderCache';
-import { DEFAULT_PATH_NORMALIZATION, LIVE_MISSES_QUERY_PARAM, LOCALE_STORAGE_KEY } from './provider/providerConstants';
-// Why: run initial load before first paint on the client to avoid a prehide flash; useEffect on SSR.
-const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
-export const LovalingoProvider = ({ children, apiKey: apiKeyProp, publicAnonKey, defaultLocale, locales, apiBase = 'https://cdn.lovalingo.com', routing = 'path', // Default to path mode (SEO-friendly, recommended)
-autoPrefixLinks = true, overlayBgColor, autoApplyRules = true, switcherPosition = 'bottom-right', switcherOffsetY = 20, switcherTheme = 'dark', editMode: initialEditMode = false, editKey = 'KeyE', pathNormalization = DEFAULT_PATH_NORMALIZATION, // Enable by default
-mode = 'dom', // Default to legacy DOM mode for backward compatibility
-sitemap = true, // Default: true - Auto-inject sitemap link tag
-seo = true, // Default: true - Can be disabled per project entitlements
-navigateRef, // For path mode routing
- }) => {
-    const metaKey = typeof document !== "undefined"
-        ? document.querySelector('meta[name="lovalingo-public-anon-key"]')?.content?.trim() || ""
-        : "";
-    const resolvedApiKey = (typeof apiKeyProp === "string" && apiKeyProp.trim().length > 0
-        ? apiKeyProp
-        : typeof publicAnonKey === "string" && publicAnonKey.trim().length > 0
-            ? publicAnonKey
-            : globalThis
-                .__LOVALINGO_PUBLIC_ANON_KEY__ ||
-                globalThis.__LOVALINGO_API_KEY__ ||
-                metaKey ||
-                "");
-    const rawLocales = Array.isArray(locales) ? locales : [];
-    // Stabilize locale lists even when callers pass inline arrays (e.g. locales={["en","de"]})
-    // so effects/callbacks don't re-run every render.
-    const localesKey = rawLocales.join(",");
-    const allLocales = useMemo(() => {
-        const base = rawLocales.includes(defaultLocale) ? rawLocales : [defaultLocale, ...rawLocales];
-        return Array.from(new Set(base));
-    }, [defaultLocale, localesKey]);
-    const pathNormalizationKey = (() => {
-        const enabled = pathNormalization?.enabled !== false;
-        const rules = Array.isArray(pathNormalization?.rules) ? pathNormalization.rules : [];
-        // Why: callers often pass inline objects/arrays; derive a stable key to prevent request storms from re-initializing effects.
-        const rulesKey = rules.map((r) => `${r.pattern}=>${r.replacement}:${r.includeSubpaths ? 1 : 0}`).join("|");
-        return `${enabled ? 1 : 0}:${rulesKey}`;
-    })();
-    const stablePathNormalization = useMemo(() => {
-        const enabled = pathNormalization?.enabled !== false;
-        const rules = Array.isArray(pathNormalization?.rules) ? pathNormalization.rules : undefined;
-        return rules ? { enabled, rules } : { enabled };
-    }, [pathNormalizationKey]);
-    // Why: read locale synchronously from the URL to avoid an initial default-locale render (EN -> FR flash) before effects run.
-    const [locale, setLocaleState] = useState(() => {
-        if (typeof window === "undefined")
-            return defaultLocale;
-        if (routing === "path") {
-            const pathLocale = window.location.pathname.split("/")[1];
-            if (pathLocale && allLocales.includes(pathLocale)) {
-                return pathLocale;
-            }
-        }
-        else if (routing === "query") {
-            const params = new URLSearchParams(window.location.search);
-            const queryLocale = params.get("t") || params.get("locale");
-            if (queryLocale && allLocales.includes(queryLocale)) {
-                return queryLocale;
-            }
-        }
-        try {
-            const stored = localStorage.getItem(LOCALE_STORAGE_KEY);
-            if (stored && allLocales.includes(stored)) {
-                return stored;
-            }
-        }
-        catch {
-            // ignore
-        }
-        return defaultLocale;
-    });
-    const initialEditParams = readEditParams();
-    const [editMode, setEditMode] = useState(initialEditMode || initialEditParams.enabled);
-    const [editSecretKey] = useState(initialEditParams.editKey);
-    const enhancedPathConfig = useMemo(() => (routing === "path" ? { ...stablePathNormalization, supportedLocales: allLocales } : stablePathNormalization), [allLocales, routing, stablePathNormalization]);
-    const apiRef = useRef(new LovalingoAPI(resolvedApiKey, apiBase, enhancedPathConfig, editSecretKey ?? undefined));
-    useEffect(() => {
-        apiRef.current = new LovalingoAPI(resolvedApiKey, apiBase, enhancedPathConfig, editSecretKey ?? undefined);
-    }, [apiBase, editSecretKey, enhancedPathConfig, resolvedApiKey]);
-    const routingConfig = useContext(LangRoutingContext);
-    const [entitlements, setEntitlements] = useState(() => apiRef.current.getEntitlements());
-    const { trackPageviewOnce } = usePageviewTracking({ apiRef, resolvedApiKey });
-    const lastNormalizedPathRef = useRef("");
-    const onNavigateRef = useRef(() => undefined);
-    const isInternalNavigationRef = useRef(false);
-    const { brandingEnabled, setBrandingEnabled, setCachedBrandingEnabled, getCachedLoadingBgColor, setCachedLoadingBgColor, } = useProviderCache({ overlayBgColor, resolvedApiKey });
-    const config = {
-        apiKey: resolvedApiKey,
-        publicAnonKey: resolvedApiKey,
-        defaultLocale,
-        locales: allLocales,
-        apiBase,
-        routing,
-        autoPrefixLinks,
-        overlayBgColor,
-        switcherPosition,
-        switcherOffsetY,
-        switcherTheme,
-        editMode: initialEditMode,
-        editKey,
-        pathNormalization,
-        mode,
-        autoApplyRules,
-    };
-    const isSeoActive = useCallback(() => {
-        // Prop can force-disable SEO; server can also disable per project.
-        const serverEnabled = entitlements?.seoEnabled;
-        if (serverEnabled === false)
-            return false;
-        return seo !== false;
-    }, [entitlements, seo]);
-    // Marker engine: always mark full DOM content for deterministic pipeline extraction.
-    useEffect(() => {
-        const stop = startMarkerEngine({ throttleMs: 120 });
-        return () => stop();
-    }, []);
-    // Detect locale from URL or localStorage
-    const detectLocale = useCallback(() => detectLocaleFromLocation({ routing, allLocales, defaultLocale }), [allLocales, defaultLocale, routing]);
-    // Fetch entitlements early so SEO can be enabled even on default locale
-    useEffect(() => {
-        if (locale !== defaultLocale)
-            return;
-        if (entitlements)
-            return;
-        let cancelled = false;
-        (async () => {
-            const bootstrap = await apiRef.current.fetchBootstrap(locale, window.location.pathname + window.location.search);
-            if (cancelled)
-                return;
-            if (bootstrap?.entitlements) {
-                setEntitlements(mergeEntitlementsSeoEnabled(bootstrap.entitlements, bootstrap.seoEnabled));
-            }
-            if (bootstrap?.loading_bg_color)
-                setCachedLoadingBgColor(bootstrap.loading_bg_color);
-            if (bootstrap?.entitlements?.brandingRequired) {
-                setBrandingEnabled(true);
-                setCachedBrandingEnabled(true);
-            }
-            else if (typeof bootstrap?.branding_enabled === "boolean") {
-                setBrandingEnabled(bootstrap.branding_enabled);
-                setCachedBrandingEnabled(bootstrap.branding_enabled);
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-    }, [defaultLocale, entitlements, locale, setCachedBrandingEnabled, setCachedLoadingBgColor]);
-    const applySeoBundle = useCallback((bundle, hreflangEnabled) => {
-        applySeoBundleInternal(bundle, hreflangEnabled);
-    }, []);
-    // Keep <html lang> in sync and apply default-locale SEO (non-default locales use the bootstrap payload).
-    useEffect(() => {
-        setDocumentLocale(locale);
-        if (locale !== defaultLocale)
-            return;
-        if (!isSeoActive())
-            return;
-        void apiRef.current.fetchSeoBundle(locale).then((bundle) => {
-            applySeoBundle(bundle, Boolean(entitlements?.hreflangEnabled));
-        });
-    }, [applySeoBundle, defaultLocale, entitlements, isSeoActive, locale, setDocumentLocale]);
-    const { isLoading, isNavigatingRef, loadData } = useBundleLoading({
-        apiRef,
-        resolvedApiKey,
-        defaultLocale,
-        routing,
-        allLocales,
-        nonLocalizedPaths: routingConfig.nonLocalizedPaths,
-        enhancedPathConfig,
-        mode,
-        autoApplyRules,
-        seoProp: seo,
-        isSeoActive,
-        applySeoBundle,
-        setEntitlements,
-        setBrandingEnabled,
-        setCachedBrandingEnabled,
-        setCachedLoadingBgColor,
-        getCachedLoadingBgColor,
-    });
-    useEffect(() => {
-        onNavigateRef.current = () => {
-            trackPageviewOnce(window.location.pathname + window.location.search);
-            const nextLocale = detectLocale();
-            const normalizedPath = processPath(window.location.pathname, enhancedPathConfig);
-            const normalizedPathChanged = normalizedPath !== lastNormalizedPathRef.current;
-            lastNormalizedPathRef.current = normalizedPath;
-            // Why: bundles are path-scoped, so SPA navigations within the same locale must trigger a reload for the new route.
-            if (normalizedPathChanged && nextLocale !== defaultLocale && !isInternalNavigationRef.current) {
-                void loadData(nextLocale, locale);
-                return;
-            }
-            if (nextLocale !== locale) {
-                setLocaleState(nextLocale);
-                if (!isInternalNavigationRef.current) {
-                    void loadData(nextLocale, locale);
-                }
-            }
-            else if (mode === "dom" && nextLocale !== defaultLocale) {
-                applyActiveTranslations(document.body);
-            }
-        };
-    }, [defaultLocale, detectLocale, enhancedPathConfig, loadData, locale, mode, trackPageviewOnce]);
-    useHistoryNavigationPatch(onNavigateRef);
-    // Change locale
-    const setLocale = useCallback((newLocale) => {
-        void (async () => {
-            if (!allLocales.includes(newLocale))
-                return;
-            // Save to localStorage
-            try {
-                localStorage.setItem(LOCALE_STORAGE_KEY, newLocale);
-            }
-            catch (e) {
-                warnDebug('Failed to save locale to localStorage:', e);
-            }
-            isInternalNavigationRef.current = true;
-            // Prevent MutationObserver work during the switch to avoid React conflicts
-            isNavigatingRef.current = true;
-            // Why: force a full reload on locale switches to avoid mixed-language DOM residues.
-            let nextUrl = "";
-            // Update URL based on routing strategy
-            if (routing === 'path') {
-                const stripped = stripLocalePrefix(window.location.pathname, allLocales);
-                if (isNonLocalizedPath(stripped, routingConfig.nonLocalizedPaths)) {
-                    // Why: switching languages must not rewrite non-localized routes like "/auth" to "/de/auth".
-                    nextUrl = window.location.href;
-                }
-                else {
-                    const pathParts = window.location.pathname.split('/').filter(Boolean);
-                    // Strip existing locale
-                    if (allLocales.includes(pathParts[0])) {
-                        pathParts.shift();
-                    }
-                    // Build new path with new locale
-                    const basePath = pathParts.join('/');
-                    nextUrl = `/${newLocale}${basePath ? '/' + basePath : ''}${window.location.search}${window.location.hash}`;
-                }
-            }
-            else if (routing === 'query') {
-                const url = new URL(window.location.href);
-                url.searchParams.set('t', newLocale);
-                nextUrl = url.toString();
-            }
-            if (!nextUrl)
-                nextUrl = window.location.href;
-            window.location.assign(nextUrl);
-            return;
-        })().finally(() => {
-            isInternalNavigationRef.current = false;
-        });
-    }, [allLocales, locale, routing, routingConfig.nonLocalizedPaths]);
-    // No string-level "misses" from the client: the pipeline (Browser Rendering) is source-of-truth for string discovery.
-    // Why: prevent init/load effects from re-running (and calling bootstrap/bundle again) when loadData changes due to state updates.
-    const loadDataRef = useRef(loadData);
-    useEffect(() => {
-        loadDataRef.current = loadData;
-    }, [loadData]);
-    const detectLocaleRef = useRef(detectLocale);
-    useEffect(() => {
-        detectLocaleRef.current = detectLocale;
-    }, [detectLocale]);
-    useEffect(() => {
-        if (editMode && !editSecretKey) {
-            warnDebug('[Lovalingo] Edit Mode is active but no edit_key was provided in the URL.');
-        }
-    }, [editMode, editSecretKey]);
-    // Initialize
-    useIsomorphicLayoutEffect(() => {
-        const applyLiveMissesQueryParam = () => {
-            if (typeof window === "undefined")
-                return;
-            const url = new URL(window.location.href);
-            const raw = url.searchParams.get(LIVE_MISSES_QUERY_PARAM);
-            if (raw !== "0" && raw !== "1")
-                return;
-            const g = window;
-            if (raw === "1") {
-                if (g.__lovalingoDisableMisses === true)
-                    return;
-                g.__lovalingoDisableMisses = false;
-                return;
-            }
-            g.__lovalingoDisableMisses = true;
-        };
-        applyLiveMissesQueryParam();
-        const initialLocale = detectLocaleRef.current();
-        lastNormalizedPathRef.current = processPath(window.location.pathname, enhancedPathConfig);
-        // Track initial page (fallback discovery for pages not present in the routes feed).
-        trackPageviewOnce(window.location.pathname + window.location.search);
-        // Always prefetch artifacts for the initial locale (pipeline-produced translations + rules).
-        loadDataRef.current(initialLocale);
-        // Set up keyboard shortcut for edit mode
-        const handleKeyPress = (e) => {
-            if (e.code === editKey && (e.ctrlKey || e.metaKey)) {
-                e.preventDefault();
-                setEditMode(prev => !prev);
-            }
-        };
-        window.addEventListener('keydown', handleKeyPress);
-        return () => {
-            window.removeEventListener('keydown', handleKeyPress);
-        };
-    }, [editKey, enhancedPathConfig, trackPageviewOnce]);
-    useSitemapLinkTag({ enabled: sitemap, resolvedApiKey, isSeoActive });
-    useLinkAutoPrefix({
-        routing,
-        autoPrefixLinks,
-        allLocales,
-        locale,
-        navigateRef,
-        nonLocalizedPaths: routingConfig.nonLocalizedPaths,
-    });
-    useNavigationPrefetch({
-        resolvedApiKey,
-        apiBase,
-        defaultLocale,
-        locale,
-        routing,
-        allLocales,
-        enhancedPathConfig,
-    });
-    useStringMissReporting({
-        apiRef,
-        resolvedApiKey,
-        locale,
-        defaultLocale,
-        routing,
-        allLocales,
-        nonLocalizedPaths: routingConfig.nonLocalizedPaths,
-        isLoading,
-        mode,
-    });
-    // Dynamic DOM updates are handled by the marker engine observer (React-safe in-place text/attr updates).
-    // No periodic string-miss reporting. Page discovery is tracked via pageview only.
-    const translateElement = useCallback((element) => {
-        if (mode !== "dom")
-            return;
-        applyActiveTranslations(element);
-    }, []);
-    const translateDOM = useCallback(() => {
-        if (mode !== "dom")
-            return;
-        applyActiveTranslations(document.body);
-    }, []);
-    const toggleEditMode = useCallback(() => {
-        setEditMode(prev => !prev);
-    }, []);
-    const excludeElement = useCallback(async (selector) => {
-        if (!editSecretKey) {
-            warnDebug('[Lovalingo] Edit Mode is active but no edit_key was provided in the URL.');
-            return;
-        }
-        // Why: store exclusions on the normalized path so they apply across locales.
-        const pagePath = lastNormalizedPathRef.current || processPath(window.location.pathname, enhancedPathConfig);
-        await apiRef.current.saveExclusion({
-            selector,
-            type: 'css',
-            pagePath,
-            editKey: editSecretKey,
-        });
-        const exclusions = await apiRef.current.fetchExclusions();
-        setMarkerEngineExclusions(exclusions);
-    }, [editSecretKey, enhancedPathConfig]);
-    useEditModeOverlay({ editMode, excludeElement, setEditMode });
-    const contextValue = {
-        locale,
-        setLocale,
-        isLoading,
-        translationMap: {},
-        config,
-        translateElement,
-        translateDOM,
-        editMode,
-        toggleEditMode,
-        excludeElement,
-    };
-    return (React.createElement(LovalingoContext.Provider, { value: contextValue },
-        children,
-        (() => {
-            if (routing !== "path")
-                return true;
-            if (typeof window === "undefined")
-                return true;
-            const stripped = stripLocalePrefix(window.location.pathname, allLocales);
-            return !isNonLocalizedPath(stripped, routingConfig.nonLocalizedPaths);
-        })() && (React.createElement(LanguageSwitcher, { locales: allLocales, currentLocale: locale, onLocaleChange: setLocale, position: switcherPosition, offsetY: switcherOffsetY, theme: switcherTheme, branding: {
-                required: Boolean(entitlements?.brandingRequired),
-                enabled: brandingEnabled,
-                href: "https://lovalingo.com",
-            } }))));
-};

package/dist/components/NavigationOverlay.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface NavigationOverlayProps {
-    isVisible: boolean;
-}
-export declare const NavigationOverlay: React.FC<NavigationOverlayProps>;
-export {};

package/dist/components/NavigationOverlay.js

@@ -1,22 +0,0 @@
-import React from 'react';
-export const NavigationOverlay = ({ isVisible }) => {
-    if (!isVisible)
-        return null;
-    return (React.createElement("div", { style: {
-            position: 'fixed',
-            top: 0,
-            left: 0,
-            right: 0,
-            bottom: 0,
-            backgroundColor: 'rgba(255, 255, 255, 0.01)',
-            zIndex: 9999,
-            animation: 'fadeIn 0.1s ease-in-out',
-            cursor: 'progress',
-        }, "data-Lovalingo-exclude": "true" },
-        React.createElement("style", null, `
-        @keyframes fadeIn {
-          from { opacity: 0; }
-          to { opacity: 1; }
-        }
-      `)));
-};

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

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

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

@@ -1,13 +0,0 @@
-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/editModeUtils.d.ts

@@ -1,6 +0,0 @@
-export declare function readEditParams(): {
-    enabled: boolean;
-    editKey: string | null;
-};
-export declare function cssEscape(value: string): string;
-export declare function buildCssSelector(element: HTMLElement, maxDepth?: number): string | null;

package/dist/components/provider/editModeUtils.js

@@ -1,59 +0,0 @@
-import { EDIT_KEY_PARAM, EDIT_MODE_PARAM, EDIT_MODE_VALUES } from './providerConstants';
-export function readEditParams() {
-    if (typeof window === 'undefined')
-        return { enabled: false, editKey: null };
-    const params = new URLSearchParams(window.location.search);
-    const rawFlag = (params.get(EDIT_MODE_PARAM) || params.get('editMode') || '').trim().toLowerCase();
-    const enabled = EDIT_MODE_VALUES.has(rawFlag);
-    const editKey = (params.get(EDIT_KEY_PARAM) || params.get('editKey') || '').trim() || null;
-    return { enabled, editKey };
-}
-export function cssEscape(value) {
-    const esc = typeof window !== 'undefined' && window?.CSS?.escape;
-    if (typeof esc === 'function')
-        return esc(value);
-    return value.replace(/[ !"#$%&'()*+,.\/:;<=>?@[\\\]^`{|}~]/g, '\\$&');
-}
-// Why: build stable, short selectors for exclusions without requiring IDs.
-export function buildCssSelector(element, maxDepth = 5) {
-    if (!element || !element.tagName)
-        return null;
-    if (element.id)
-        return `#${cssEscape(element.id)}`;
-    const parts = [];
-    let node = element;
-    let depth = 0;
-    while (node && depth < maxDepth) {
-        const tag = node.tagName.toLowerCase();
-        if (!tag || tag === 'html')
-            break;
-        let part = tag;
-        const nodeTag = node.tagName;
-        const classes = Array.from(node.classList || [])
-            .filter(Boolean)
-            .filter((cls) => !cls.startsWith('lovalingo-'))
-            .slice(0, 2);
-        if (classes.length > 0) {
-            part += `.${classes.map(cssEscape).join('.')}`;
-        }
-        const parentEl = node.parentElement;
-        if (parentEl) {
-            const siblings = Array.from(parentEl.children).filter((child) => child instanceof HTMLElement && child.tagName === nodeTag);
-            if (siblings.length > 1) {
-                part += `:nth-of-type(${siblings.indexOf(node) + 1})`;
-            }
-        }
-        parts.unshift(part);
-        const selector = parts.join(' > ');
-        try {
-            if (document.querySelectorAll(selector).length === 1)
-                return selector;
-        }
-        catch {
-            // ignore invalid selector attempts
-        }
-        node = parentEl;
-        depth += 1;
-    }
-    return parts.join(' > ') || null;
-}

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

@@ -1,8 +0,0 @@
-type DetectLocaleArgs = {
-    routing: 'path' | 'query';
-    allLocales: string[];
-    defaultLocale: string;
-};
-export declare function detectLocaleFromLocation({ routing, allLocales, defaultLocale }: DetectLocaleArgs): string;
-export declare function setDocumentLocale(nextLocale: string): void;
-export {};

package/dist/components/provider/localeUtils.js

@@ -1,46 +0,0 @@
-import { warnDebug } from '../../utils/logger';
-import { LOCALE_STORAGE_KEY } from './providerConstants';
-export function detectLocaleFromLocation({ routing, allLocales, defaultLocale }) {
-    // 1. Check URL first based on routing mode
-    if (routing === 'path') {
-        // Path mode: language is in path (/en/pricing, /fr/about)
-        const pathLocale = window.location.pathname.split('/')[1];
-        if (pathLocale && allLocales.includes(pathLocale)) {
-            return pathLocale;
-        }
-    }
-    else if (routing === 'query') {
-        // Query mode: language is in query param (/pricing?t=fr)
-        const params = new URLSearchParams(window.location.search);
-        const queryLocale = params.get('t') || params.get('locale');
-        if (queryLocale && allLocales.includes(queryLocale)) {
-            return queryLocale;
-        }
-    }
-    // 2. Check localStorage (fallback for all routing modes)
-    try {
-        const storedLocale = localStorage.getItem(LOCALE_STORAGE_KEY);
-        if (storedLocale && allLocales.includes(storedLocale)) {
-            return storedLocale;
-        }
-    }
-    catch (e) {
-        // localStorage might be unavailable (SSR, private browsing)
-        warnDebug('localStorage not available:', e);
-    }
-    // 3. Default locale
-    return defaultLocale;
-}
-export function setDocumentLocale(nextLocale) {
-    try {
-        const html = document.documentElement;
-        if (!html)
-            return;
-        html.setAttribute('lang', nextLocale);
-        const rtlLocales = new Set(['ar', 'he', 'fa', 'ur']);
-        html.setAttribute('dir', rtlLocales.has(nextLocale) ? 'rtl' : 'ltr');
-    }
-    catch {
-        // ignore
-    }
-}

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

@@ -1,12 +0,0 @@
-import type { PathNormalizationConfig } from '../../utils/pathNormalizer';
-export declare const LOCALE_STORAGE_KEY = "Lovalingo_locale";
-export declare const LOADING_BG_STORAGE_PREFIX = "Lovalingo_loading_bg_color";
-export declare const BRANDING_STORAGE_PREFIX = "Lovalingo_branding_enabled";
-export declare const EDIT_MODE_PARAM = "edit_mode";
-export declare const EDIT_KEY_PARAM = "edit_key";
-export declare const LIVE_MISSES_QUERY_PARAM = "lovalingo_live_misses";
-export declare const DEFAULT_PATH_NORMALIZATION: PathNormalizationConfig;
-export declare const EDIT_MODE_VALUES: Set<string>;
-export declare const EDIT_UI_ATTR = "data-lovalingo-edit-ui";
-export declare const EDIT_HIGHLIGHT_ID = "lovalingo-edit-highlight";
-export declare const EDIT_HINT_ID = "lovalingo-edit-hint";

package/dist/components/provider/providerConstants.js

@@ -1,11 +0,0 @@
-export const LOCALE_STORAGE_KEY = 'Lovalingo_locale';
-export const LOADING_BG_STORAGE_PREFIX = 'Lovalingo_loading_bg_color';
-export const BRANDING_STORAGE_PREFIX = 'Lovalingo_branding_enabled';
-export const EDIT_MODE_PARAM = 'edit_mode';
-export const EDIT_KEY_PARAM = 'edit_key';
-export const LIVE_MISSES_QUERY_PARAM = 'lovalingo_live_misses';
-export const DEFAULT_PATH_NORMALIZATION = { enabled: true };
-export const EDIT_MODE_VALUES = new Set(['1', 'true', 'yes', 'on']);
-export const EDIT_UI_ATTR = 'data-lovalingo-edit-ui';
-export const EDIT_HIGHLIGHT_ID = 'lovalingo-edit-highlight';
-export const EDIT_HINT_ID = 'lovalingo-edit-hint';

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

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