@lovalingo/lovalingo 0.5.25 → 0.5.28

package/dist/components/provider/localeUtils.js

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,8 @@
+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;

package/dist/components/provider/seoUtils.js

@@ -0,0 +1,118 @@
+export function applySeoBundle(bundle, hreflangEnabled) {
+    try {
+        const head = document.head;
+        if (!head)
+            return;
+        if (!bundle)
+            return;
+        const seo = (bundle?.seo && typeof bundle.seo === 'object' ? bundle.seo : {});
+        const alternates = (bundle?.alternates && typeof bundle.alternates === 'object' ? bundle.alternates : {});
+        const setOrCreateMeta = (attrs, content) => {
+            const key = attrs.name ? `meta[name="${attrs.name}"]` : attrs.property ? `meta[property="${attrs.property}"]` : '';
+            const selector = key || 'meta';
+            const existing = selector ? head.querySelector(selector) : null;
+            const el = existing || document.createElement('meta');
+            for (const [k, v] of Object.entries(attrs)) {
+                el.setAttribute(k, v);
+            }
+            el.setAttribute('content', content);
+            if (!existing)
+                head.appendChild(el);
+        };
+        const setOrCreateTitle = (value) => {
+            const existing = head.querySelector('title');
+            if (existing) {
+                existing.textContent = value;
+                return;
+            }
+            const el = document.createElement('title');
+            el.textContent = value;
+            head.appendChild(el);
+        };
+        const getString = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+        const title = getString(seo.title);
+        if (title)
+            setOrCreateTitle(title);
+        const description = getString(seo.description);
+        if (description)
+            setOrCreateMeta({ name: 'description' }, description);
+        const robots = getString(seo.robots);
+        if (robots)
+            setOrCreateMeta({ name: 'robots' }, robots);
+        const ogTitle = getString(seo.og_title);
+        if (ogTitle)
+            setOrCreateMeta({ property: 'og:title' }, ogTitle);
+        const ogDescription = getString(seo.og_description);
+        if (ogDescription)
+            setOrCreateMeta({ property: 'og:description' }, ogDescription);
+        const ogImage = getString(seo.og_image);
+        if (ogImage)
+            setOrCreateMeta({ property: 'og:image' }, ogImage);
+        const ogImageAlt = getString(seo.og_image_alt);
+        if (ogImageAlt)
+            setOrCreateMeta({ property: 'og:image:alt' }, ogImageAlt);
+        const twitterCard = getString(seo.twitter_card);
+        if (twitterCard)
+            setOrCreateMeta({ name: 'twitter:card' }, twitterCard);
+        const twitterTitle = getString(seo.twitter_title);
+        if (twitterTitle)
+            setOrCreateMeta({ name: 'twitter:title' }, twitterTitle);
+        const twitterDescription = getString(seo.twitter_description);
+        if (twitterDescription)
+            setOrCreateMeta({ name: 'twitter:description' }, twitterDescription);
+        const twitterImage = getString(seo.twitter_image);
+        if (twitterImage)
+            setOrCreateMeta({ name: 'twitter:image' }, twitterImage);
+        const twitterImageAlt = getString(seo.twitter_image_alt);
+        if (twitterImageAlt)
+            setOrCreateMeta({ name: 'twitter:image:alt' }, twitterImageAlt);
+        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))
+            return;
+        // Why: search engines may ignore hreflang/canonical when multiple conflicting tags exist (we want sitemap + head parity).
+        head
+            .querySelectorAll('link[rel="canonical"], link[rel="alternate"][hreflang], link[data-Lovalingo="hreflang"], link[data-Lovalingo="canonical"]')
+            .forEach((el) => el.remove());
+        if (canonicalHref) {
+            const canonical = document.createElement('link');
+            canonical.rel = 'canonical';
+            canonical.href = canonicalHref;
+            canonical.setAttribute('data-Lovalingo', 'canonical');
+            head.appendChild(canonical);
+        }
+        if (!hreflangEnabled)
+            return;
+        for (const [lang, href] of Object.entries(languages)) {
+            if (!href)
+                continue;
+            const link = document.createElement('link');
+            link.rel = 'alternate';
+            link.hreflang = lang;
+            link.href = href;
+            link.setAttribute('data-Lovalingo', 'hreflang');
+            head.appendChild(link);
+        }
+        if (alternates.xDefault) {
+            const xDefault = document.createElement('link');
+            xDefault.rel = 'alternate';
+            xDefault.hreflang = 'x-default';
+            xDefault.href = alternates.xDefault;
+            xDefault.setAttribute('data-Lovalingo', 'hreflang');
+            head.appendChild(xDefault);
+        }
+    }
+    catch {
+        // 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/components/provider/useEditModeOverlay.d.ts

@@ -0,0 +1,7 @@
+type UseEditModeOverlayArgs = {
+    editMode: boolean;
+    excludeElement: (selector: string) => Promise<void>;
+    setEditMode: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export declare function useEditModeOverlay({ editMode, excludeElement, setEditMode }: UseEditModeOverlayArgs): void;
+export {};

package/dist/components/provider/useEditModeOverlay.js

@@ -0,0 +1,134 @@
+import { useEffect, useRef } from 'react';
+import { buildCssSelector } from './editModeUtils';
+import { EDIT_HINT_ID, EDIT_HIGHLIGHT_ID, EDIT_UI_ATTR } from './providerConstants';
+export function useEditModeOverlay({ editMode, excludeElement, setEditMode }) {
+    const editSavingRef = useRef(false);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const existingHighlight = document.getElementById(EDIT_HIGHLIGHT_ID);
+        const existingHint = document.getElementById(EDIT_HINT_ID);
+        if (!editMode) {
+            existingHighlight?.remove();
+            existingHint?.remove();
+            return;
+        }
+        const highlight = existingHighlight ||
+            (() => {
+                const node = document.createElement('div');
+                node.id = EDIT_HIGHLIGHT_ID;
+                node.setAttribute(EDIT_UI_ATTR, 'true');
+                node.setAttribute('data-lovalingo-exclude', 'true');
+                node.style.position = 'fixed';
+                node.style.pointerEvents = 'none';
+                node.style.zIndex = '2147483646';
+                node.style.border = '2px solid #22c55e';
+                node.style.background = 'rgba(34, 197, 94, 0.12)';
+                node.style.borderRadius = '8px';
+                node.style.boxSizing = 'border-box';
+                node.style.transition = 'transform 80ms ease, width 80ms ease, height 80ms ease';
+                node.style.display = 'none';
+                document.body.appendChild(node);
+                return node;
+            })();
+        const hint = existingHint ||
+            (() => {
+                const node = document.createElement('div');
+                node.id = EDIT_HINT_ID;
+                node.setAttribute(EDIT_UI_ATTR, 'true');
+                node.setAttribute('data-lovalingo-exclude', 'true');
+                node.style.position = 'fixed';
+                node.style.left = '12px';
+                node.style.bottom = '12px';
+                node.style.zIndex = '2147483647';
+                node.style.background = 'rgba(10, 10, 10, 0.85)';
+                node.style.color = '#ffffff';
+                node.style.fontSize = '12px';
+                node.style.lineHeight = '1.4';
+                node.style.padding = '8px 10px';
+                node.style.borderRadius = '8px';
+                node.style.border = '1px solid rgba(255, 255, 255, 0.15)';
+                node.style.pointerEvents = 'none';
+                node.style.maxWidth = '280px';
+                node.textContent = 'Edit Mode: click an element to exclude. Press Esc to exit.';
+                document.body.appendChild(node);
+                return node;
+            })();
+        let rafId = null;
+        let pendingTarget = null;
+        const previousCursor = document.body.style.cursor;
+        document.body.style.cursor = 'crosshair';
+        const updateHighlight = () => {
+            rafId = null;
+            if (!pendingTarget) {
+                highlight.style.display = 'none';
+                return;
+            }
+            const rect = pendingTarget.getBoundingClientRect();
+            if (rect.width <= 0 || rect.height <= 0) {
+                highlight.style.display = 'none';
+                return;
+            }
+            highlight.style.display = 'block';
+            highlight.style.width = `${rect.width}px`;
+            highlight.style.height = `${rect.height}px`;
+            highlight.style.transform = `translate(${rect.left}px, ${rect.top}px)`;
+        };
+        const onMove = (event) => {
+            const rawTarget = event.target;
+            const target = rawTarget instanceof HTMLElement ? rawTarget : rawTarget instanceof Node ? rawTarget.parentElement : null;
+            if (!target || target.closest(`[${EDIT_UI_ATTR}="true"]`)) {
+                pendingTarget = null;
+            }
+            else if (target === document.body || target === document.documentElement) {
+                pendingTarget = null;
+            }
+            else {
+                pendingTarget = target;
+            }
+            if (rafId !== null)
+                return;
+            rafId = window.requestAnimationFrame(updateHighlight);
+        };
+        const onClick = async (event) => {
+            const rawTarget = event.target;
+            const target = rawTarget instanceof HTMLElement ? rawTarget : rawTarget instanceof Node ? rawTarget.parentElement : null;
+            if (!target || target.closest(`[${EDIT_UI_ATTR}="true"]`))
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            event.stopImmediatePropagation();
+            const selector = buildCssSelector(target);
+            if (!selector)
+                return;
+            if (editSavingRef.current)
+                return;
+            editSavingRef.current = true;
+            try {
+                await excludeElement(selector);
+            }
+            finally {
+                editSavingRef.current = false;
+            }
+        };
+        const onKeyDown = (event) => {
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                setEditMode(false);
+            }
+        };
+        document.addEventListener('mousemove', onMove, true);
+        document.addEventListener('click', onClick, true);
+        document.addEventListener('keydown', onKeyDown, true);
+        return () => {
+            document.removeEventListener('mousemove', onMove, true);
+            document.removeEventListener('click', onClick, true);
+            document.removeEventListener('keydown', onKeyDown, true);
+            if (rafId !== null)
+                window.cancelAnimationFrame(rafId);
+            highlight.remove();
+            hint.remove();
+            document.body.style.cursor = previousCursor;
+        };
+    }, [editMode, excludeElement, setEditMode]);
+}

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

@@ -0,0 +1,3 @@
+type OnNavigateRef = React.MutableRefObject<() => void>;
+export declare function useHistoryNavigationPatch(onNavigateRef: OnNavigateRef): void;
+export {};

package/dist/components/provider/useHistoryNavigationPatch.js

@@ -0,0 +1,47 @@
+import { useEffect, useRef } from 'react';
+export function useHistoryNavigationPatch(onNavigateRef) {
+    const historyPatchedRef = useRef(false);
+    const originalHistoryRef = useRef(null);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        if (historyPatchedRef.current)
+            return;
+        historyPatchedRef.current = true;
+        const historyObj = window.history;
+        const originalPushState = historyObj.pushState.bind(historyObj);
+        const originalReplaceState = historyObj.replaceState.bind(historyObj);
+        originalHistoryRef.current = { pushState: originalPushState, replaceState: originalReplaceState };
+        const safeOnNavigate = () => {
+            try {
+                onNavigateRef.current();
+            }
+            catch {
+                // ignore
+            }
+        };
+        historyObj.pushState = ((...args) => {
+            const ret = originalPushState(...args);
+            safeOnNavigate();
+            return ret;
+        });
+        historyObj.replaceState = ((...args) => {
+            const ret = originalReplaceState(...args);
+            safeOnNavigate();
+            return ret;
+        });
+        window.addEventListener('popstate', safeOnNavigate);
+        window.addEventListener('hashchange', safeOnNavigate);
+        return () => {
+            const originals = originalHistoryRef.current;
+            if (originals) {
+                historyObj.pushState = originals.pushState;
+                historyObj.replaceState = originals.replaceState;
+            }
+            window.removeEventListener('popstate', safeOnNavigate);
+            window.removeEventListener('hashchange', safeOnNavigate);
+            originalHistoryRef.current = null;
+            historyPatchedRef.current = false;
+        };
+    }, [onNavigateRef]);
+}

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

@@ -0,0 +1,12 @@
+type UseProviderCacheArgs = {
+    overlayBgColor?: string | null;
+    resolvedApiKey: string;
+};
+export declare function useProviderCache({ overlayBgColor, resolvedApiKey }: UseProviderCacheArgs): {
+    readonly brandingEnabled: boolean;
+    readonly setBrandingEnabled: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    readonly setCachedBrandingEnabled: (enabled: boolean | null | undefined) => void;
+    readonly getCachedLoadingBgColor: () => string;
+    readonly setCachedLoadingBgColor: (color: string | null | undefined) => void;
+};
+export {};

package/dist/components/provider/useProviderCache.js

@@ -0,0 +1,82 @@
+import { useCallback, useEffect, useState } from 'react';
+import { BRANDING_STORAGE_PREFIX, LOADING_BG_STORAGE_PREFIX } from './providerConstants';
+export function useProviderCache({ overlayBgColor, resolvedApiKey }) {
+    const loadingBgStorageKey = `${LOADING_BG_STORAGE_PREFIX}:${resolvedApiKey || 'anonymous'}`;
+    const brandingStorageKey = `${BRANDING_STORAGE_PREFIX}:${resolvedApiKey || 'anonymous'}`;
+    const readBrandingCache = useCallback(() => {
+        try {
+            const cached = (localStorage.getItem(brandingStorageKey) || '').trim();
+            if (cached === '0')
+                return false;
+            if (cached === '1')
+                return true;
+        }
+        catch {
+            // ignore
+        }
+        return true;
+    }, [brandingStorageKey]);
+    const [brandingEnabled, setBrandingEnabled] = useState(readBrandingCache);
+    const getCachedLoadingBgColor = useCallback(() => {
+        const configured = (overlayBgColor || '').toString().trim();
+        if (/^#[0-9a-fA-F]{6}$/.test(configured))
+            return configured;
+        try {
+            const cached = localStorage.getItem(loadingBgStorageKey) || '';
+            if (/^#[0-9a-fA-F]{6}$/.test(cached.trim()))
+                return cached.trim();
+        }
+        catch {
+            // ignore
+        }
+        // Why: default to the site's existing background to reduce a visible white flash on non-white themes.
+        try {
+            const bodyBg = window.getComputedStyle(document.body).backgroundColor;
+            if (bodyBg && bodyBg !== 'transparent' && bodyBg !== 'rgba(0, 0, 0, 0)')
+                return bodyBg;
+            const htmlBg = window.getComputedStyle(document.documentElement).backgroundColor;
+            if (htmlBg && htmlBg !== 'transparent' && htmlBg !== 'rgba(0, 0, 0, 0)')
+                return htmlBg;
+        }
+        catch {
+            // ignore
+        }
+        return '#ffffff';
+    }, [loadingBgStorageKey, overlayBgColor]);
+    const setCachedLoadingBgColor = useCallback((color) => {
+        const next = (color || '').toString().trim();
+        if (!/^#[0-9a-fA-F]{6}$/.test(next))
+            return;
+        try {
+            localStorage.setItem(loadingBgStorageKey, next);
+        }
+        catch {
+            // ignore
+        }
+    }, [loadingBgStorageKey]);
+    useEffect(() => {
+        // Why: make `overlayBgColor` the source of truth while keeping the existing cache key for backwards compatibility.
+        const configured = (overlayBgColor || '').toString().trim();
+        if (!/^#[0-9a-fA-F]{6}$/.test(configured))
+            return;
+        setCachedLoadingBgColor(configured);
+    }, [overlayBgColor, setCachedLoadingBgColor]);
+    const setCachedBrandingEnabled = useCallback((enabled) => {
+        try {
+            localStorage.setItem(brandingStorageKey, enabled === false ? '0' : '1');
+        }
+        catch {
+            // ignore
+        }
+    }, [brandingStorageKey]);
+    useEffect(() => {
+        setBrandingEnabled(readBrandingCache());
+    }, [readBrandingCache]);
+    return {
+        brandingEnabled,
+        setBrandingEnabled,
+        setCachedBrandingEnabled,
+        getCachedLoadingBgColor,
+        setCachedLoadingBgColor,
+    };
+}

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/api.d.ts

@@ -1,82 +1,7 @@
-import { Translation, Exclusion, DomRule } from '../types';
+import type { Translation, Exclusion, DomRule } from '../types';
+import type { BootstrapResponse, MissReportItem, MissReportOptions, MissReportResponse, ProjectEntitlements, SeoBundleResponse } from './apiTypes';
 import { PathNormalizationConfig } from './pathNormalizer';
-export interface ProjectEntitlements {
-    tier: 'starter' | 'startup' | 'global';
-    maxTargetLocales: number;
-    allowedTargetLocales: string[];
-    brandingRequired: boolean;
-    hreflangEnabled: boolean;
-    seoEnabled?: boolean;
-}
-export type SeoBundleResponse = {
-    locale?: string;
-    normalized_path?: string;
-    routing_strategy?: string;
-    seo?: Record<string, unknown>;
-    alternates?: {
-        canonical?: string;
-        xDefault?: string;
-        languages?: Record<string, string>;
-    };
-    seoEnabled?: boolean;
-    entitlements?: ProjectEntitlements;
-};
-export type BootstrapResponse = {
-    locale?: string;
-    normalized_path?: string;
-    routing_strategy?: string;
-    non_localized_paths?: Array<{
-        pattern?: string;
-        match_type?: string;
-        updated_at?: string | null;
-    }>;
-    inactive_pages?: Array<{
-        page_path?: string;
-        updated_at?: string | null;
-    }>;
-    loading_bg_color?: string | null;
-    branding_enabled?: boolean;
-    seoEnabled?: boolean;
-    entitlements?: ProjectEntitlements;
-    alternates?: {
-        canonical?: string;
-        xDefault?: string;
-        languages?: Record<string, string>;
-    } | null;
-    seo?: Record<string, unknown>;
-    jsonld?: Array<{
-        type: string;
-        json: unknown;
-        hash?: string;
-    }>;
-    dom_rules?: DomRule[];
-    exclusions?: unknown[];
-    critical?: {
-        map?: Record<string, string>;
-        keys?: number;
-        viewport?: unknown;
-        etag?: string;
-    };
-    etag?: string;
-};
-export type MissReportItem = {
-    source_text: string;
-    semantic_context?: string | null;
-};
-export type MissReportResponse = {
-    translations?: Array<{
-        source_text: string;
-        translated_text: string;
-    }>;
-    pii?: string[];
-    ignored?: boolean;
-    reason?: string;
-};
-export type MissReportOptions = {
-    pathOrUrl?: string;
-    sourceLocale?: string;
-    locales?: string[];
-};
+export type { ProjectEntitlements, SeoBundleResponse, BootstrapResponse, MissReportItem, MissReportResponse, MissReportOptions } from './apiTypes';
 export declare class LovalingoAPI {
     private apiKey;
     private apiBase;