@lovalingo/lovalingo 0.5.2 → 0.5.4

package/LICENSE

@@ -1,9 +1,9 @@
 LOVALINGO COMMERCIAL LICENSE
 
-Copyright (c) 2025 Mertens Advies. All rights reserved.
+Copyright (c) 2025 Lovalingo Swiss. All rights reserved.
 
 NOTICE: This software and associated documentation files (the "Software") are the
-proprietary and confidential information of Mertens Advies.
+proprietary and confidential information of Lovalingo Swiss.
 
 The Software is licensed, not sold. This license grants you the following rights:
 
@@ -74,17 +74,17 @@ FOR END CLIENTS:
 4. API KEY REQUIREMENT
 ====================================================================================
 
-Production use of the Software requires a valid API key obtained from Mertens Advies.
+Production use of the Software requires a valid API key obtained from Lovalingo Swiss.
 Usage is subject to the terms of service associated with your API key subscription.
 
 ====================================================================================
 5. INTELLECTUAL PROPERTY
 ====================================================================================
 
-This Software is the exclusive intellectual property of Mertens Advies.
+This Software is the exclusive intellectual property of Lovalingo Swiss.
 All rights, title, and interest in and to the Software, including all
 intellectual property rights, patents, trademarks, copyrights, and trade secrets,
-remain the sole property of Mertens Advies.
+remain the sole property of Lovalingo Swiss.
 
 ====================================================================================
 6. NOT OPEN SOURCE
@@ -133,16 +133,16 @@ SUCH DAMAGE.
 ====================================================================================
 
 This license shall be governed by and construed in accordance with the laws of
-the jurisdiction in which Mertens Advies operates, without regard to its conflict
+the jurisdiction in which Lovalingo Swiss operates, without regard to its conflict
 of law provisions.
 
 ====================================================================================
 
 For licensing inquiries, enterprise licensing, or questions about permitted use,
-please contact Mertens Advies.
+please contact Lovalingo Swiss.
 
 MERTENS ADVIES
 Lovalingo Translation Platform
 © 2025 All Rights Reserved
 
-Website: [Contact Mertens Advies for licensing information]
+Website: [Contact Lovalingo Swiss for licensing information]

package/README.md

@@ -55,7 +55,7 @@ export function App() {
   const navigateRef = useRef();
 
   return (
-    <LangRouter defaultLang="en" langs={["en", "de", "fr"]} navigateRef={navigateRef}>
+    <LangRouter publicAnonKey="aix_your_public_anon_key" defaultLang="en" langs={["en", "de", "fr"]} navigateRef={navigateRef}>
       <LovalingoProvider
         publicAnonKey="aix_your_public_anon_key"
         defaultLocale="en"
@@ -349,7 +349,7 @@ export async function GET() {
 
 **COMMERCIAL LICENSE - NOT OPEN SOURCE**
 
-Copyright (c) 2025 Mertens Advies. All rights reserved.
+Copyright (c) 2025 Lovalingo Swiss. All rights reserved.
 
 ### For Agencies & Developers
 
@@ -374,6 +374,6 @@ applications containing Lovalingo, but may not modify, redistribute, or extract
 
 This software is licensed under the **Lovalingo Commercial License**.
 This is NOT open source software. All intellectual property rights remain the
-exclusive property of Mertens Advies.
+exclusive property of Lovalingo Swiss.
 
 See LICENSE file for complete terms and conditions.

package/dist/components/AixsterProvider.js

@@ -1,10 +1,12 @@
-import React, { useMemo, useState, useEffect, useCallback, useRef } from 'react';
+import React, { useMemo, useState, useEffect, useCallback, useRef, useContext } from 'react';
 import { LovalingoContext } from '../context/LovalingoContext';
+import { LangRoutingContext } from '../context/LangRoutingContext';
 import { LovalingoAPI } from '../utils/api';
 import { applyDomRules } from '../utils/domRules';
 import { hashContent } from '../utils/hash';
 import { applyActiveTranslations, getCriticalFingerprint, restoreDom, setActiveTranslations, setMarkerEngineExclusions, startMarkerEngine } from '../utils/markerEngine';
 import { logDebug, warnDebug, errorDebug } from '../utils/logger';
+import { isNonLocalizedPath, stripLocalePrefix } from '../utils/nonLocalizedPaths';
 import { processPath } from '../utils/pathNormalizer';
 import { LanguageSwitcher } from './LanguageSwitcher';
 const LOCALE_STORAGE_KEY = 'Lovalingo_locale';
@@ -75,6 +77,7 @@ navigateRef, // For path mode routing
     useEffect(() => {
         apiRef.current = new LovalingoAPI(resolvedApiKey, apiBase, enhancedPathConfig);
     }, [apiBase, enhancedPathConfig, resolvedApiKey]);
+    const routingConfig = useContext(LangRoutingContext);
     const [entitlements, setEntitlements] = useState(() => apiRef.current.getEntitlements());
     const lastPageviewRef = useRef("");
     const lastPageviewFingerprintRef = useRef("");
@@ -111,6 +114,7 @@ navigateRef, // For path mode routing
     const prehideStateRef = useRef({
         active: false,
         timeoutId: null,
+        startedAtMs: null,
         prevHtmlVisibility: "",
         prevBodyVisibility: "",
         prevHtmlBg: "",
@@ -195,6 +199,27 @@ navigateRef, // For path mode routing
         pageviewFingerprintTimeoutRef.current = window.setTimeout(trySendFingerprint, 800);
         pageviewFingerprintRetryTimeoutRef.current = window.setTimeout(trySendFingerprint, 2000);
     }, []);
+    const forceDisablePrehide = useCallback(() => {
+        if (typeof document === "undefined")
+            return;
+        const html = document.documentElement;
+        const body = document.body;
+        if (!html || !body)
+            return;
+        const state = prehideStateRef.current;
+        if (state.timeoutId != null) {
+            window.clearTimeout(state.timeoutId);
+            state.timeoutId = null;
+        }
+        if (!state.active)
+            return;
+        state.active = false;
+        state.startedAtMs = null;
+        html.style.visibility = state.prevHtmlVisibility;
+        body.style.visibility = state.prevBodyVisibility;
+        html.style.backgroundColor = state.prevHtmlBg;
+        body.style.backgroundColor = state.prevBodyBg;
+    }, []);
     const enablePrehide = useCallback((bgColor) => {
         if (typeof document === "undefined")
             return;
@@ -203,8 +228,13 @@ navigateRef, // For path mode routing
         if (!html || !body)
             return;
         const state = prehideStateRef.current;
+        // Why: avoid "perma-hidden" pages when repeated navigation/errors keep prehide active; always hard-stop after a few seconds.
+        if (state.active && state.startedAtMs != null && Date.now() - state.startedAtMs > PREHIDE_FAILSAFE_MS * 3) {
+            forceDisablePrehide();
+        }
         if (!state.active) {
             state.active = true;
+            state.startedAtMs = Date.now();
             state.prevHtmlVisibility = html.style.visibility || "";
             state.prevBodyVisibility = body.style.visibility || "";
             state.prevHtmlBg = html.style.backgroundColor || "";
@@ -220,28 +250,9 @@ navigateRef, // For path mode routing
             return;
         }
         // Why: avoid a "perma-hide" when navigation events repeatedly re-trigger prehide and keep extending the timeout.
-        state.timeoutId = window.setTimeout(() => disablePrehide(), PREHIDE_FAILSAFE_MS);
-    }, []);
-    const disablePrehide = useCallback(() => {
-        if (typeof document === "undefined")
-            return;
-        const html = document.documentElement;
-        const body = document.body;
-        if (!html || !body)
-            return;
-        const state = prehideStateRef.current;
-        if (state.timeoutId != null) {
-            window.clearTimeout(state.timeoutId);
-            state.timeoutId = null;
-        }
-        if (!state.active)
-            return;
-        state.active = false;
-        html.style.visibility = state.prevHtmlVisibility;
-        body.style.visibility = state.prevBodyVisibility;
-        html.style.backgroundColor = state.prevHtmlBg;
-        body.style.backgroundColor = state.prevBodyBg;
-    }, []);
+        state.timeoutId = window.setTimeout(() => forceDisablePrehide(), PREHIDE_FAILSAFE_MS);
+    }, [forceDisablePrehide]);
+    const disablePrehide = forceDisablePrehide;
     const buildCriticalCacheKey = useCallback((targetLocale, normalizedPath) => {
         const key = `${resolvedApiKey || "anonymous"}:${targetLocale}:${normalizedPath || "/"}`;
         return `${CRITICAL_CACHE_PREFIX}:${hashContent(key)}`;
@@ -554,6 +565,17 @@ navigateRef, // For path mode routing
             isNavigatingRef.current = false;
             return;
         }
+        if (routing === "path") {
+            const stripped = stripLocalePrefix(window.location.pathname, allLocales);
+            if (isNonLocalizedPath(stripped, routingConfig.nonLocalizedPaths)) {
+                // Why: auth/admin (non-localized) routes must never be blocked or mutated by the translation runtime.
+                disablePrehide();
+                setActiveTranslations(null);
+                restoreDom(document.body);
+                isNavigatingRef.current = false;
+                return;
+            }
+        }
         const currentPath = window.location.pathname + window.location.search;
         const normalizedPath = processPath(window.location.pathname, enhancedPathConfig);
         const cacheKey = `${targetLocale}:${normalizedPath}`;
@@ -740,6 +762,7 @@ navigateRef, // For path mode routing
         }
     }, [
         applySeoBundle,
+        allLocales,
         autoApplyRules,
         defaultLocale,
         disablePrehide,
@@ -749,6 +772,8 @@ navigateRef, // For path mode routing
         isSeoActive,
         mode,
         readCriticalCache,
+        routing,
+        routingConfig.nonLocalizedPaths,
         setCachedLoadingBgColor,
         toTranslations,
         writeCriticalCache,
@@ -837,6 +862,13 @@ navigateRef, // For path mode routing
             isNavigatingRef.current = true;
             // 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".
+                    setLocaleState(newLocale);
+                    isNavigatingRef.current = false;
+                    return;
+                }
                 const pathParts = window.location.pathname.split('/').filter(Boolean);
                 // Strip existing locale
                 if (allLocales.includes(pathParts[0])) {
@@ -869,7 +901,7 @@ navigateRef, // For path mode routing
         })().finally(() => {
             isInternalNavigationRef.current = false;
         });
-    }, [allLocales, locale, routing, loadData, navigateRef]);
+    }, [allLocales, defaultLocale, locale, routing, loadData, navigateRef, routingConfig.nonLocalizedPaths]);
     // No string-level "misses" from the client: the pipeline (Browser Rendering) is source-of-truth for string discovery.
     // Initialize
     useEffect(() => {
@@ -929,13 +961,6 @@ navigateRef, // For path mode routing
         if (!autoPrefixLinks)
             return;
         const supportedLocales = allLocales;
-        const isAssetPath = (pathname) => {
-            if (pathname === '/robots.txt' || pathname === '/sitemap.xml')
-                return true;
-            if (pathname.startsWith('/.well-known/'))
-                return true;
-            return /\.(?:png|jpg|jpeg|gif|svg|webp|avif|ico|css|js|map|json|xml|txt|pdf|zip|gz|br|woff2?|ttf|eot)$/i.test(pathname);
-        };
         const shouldProcessCurrentPath = () => {
             const parts = window.location.pathname.split('/').filter(Boolean);
             return parts.length > 0 && supportedLocales.includes(parts[0]);
@@ -963,7 +988,7 @@ navigateRef, // For path mode routing
             }
             if (url.origin !== window.location.origin)
                 return null;
-            if (isAssetPath(url.pathname))
+            if (isNonLocalizedPath(url.pathname, routingConfig.nonLocalizedPaths))
                 return null;
             const parts = url.pathname.split('/').filter(Boolean);
             // Root ("/") should be locale-prefixed too (e.g. clicking a logo linking to "https://example.com")
@@ -1070,7 +1095,7 @@ navigateRef, // For path mode routing
             mo.disconnect();
             document.removeEventListener('click', onClickCapture, true);
         };
-    }, [routing, autoPrefixLinks, allLocales, locale, navigateRef]);
+    }, [routing, autoPrefixLinks, allLocales, locale, navigateRef, routingConfig.nonLocalizedPaths]);
     // Navigation prefetch: warm the HTTP cache for bootstrap + page bundle before the user clicks (reduces EN→FR flash on SPA route changes).
     useEffect(() => {
         if (!resolvedApiKey)
@@ -1182,9 +1207,16 @@ navigateRef, // For path mode routing
     };
     return (React.createElement(LovalingoContext.Provider, { value: contextValue },
         children,
-        React.createElement(LanguageSwitcher, { locales: allLocales, currentLocale: locale, onLocaleChange: setLocale, position: switcherPosition, offsetY: switcherOffsetY, theme: switcherTheme, branding: {
+        (() => {
+            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/LangLink.js

@@ -1,10 +1,9 @@
 import React from 'react';
 import { Link } from 'react-router-dom';
 import { useLang } from '../hooks/useLang';
-const NON_LOCALIZED_APP_PATHS = new Set([
-    'robots.txt',
-    'sitemap.xml',
-]);
+import { useContext } from 'react';
+import { LangRoutingContext } from '../context/LangRoutingContext';
+import { isNonLocalizedPath } from '../utils/nonLocalizedPaths';
 /**
  * LangLink - Language-aware Link component
  *
@@ -24,12 +23,15 @@ const NON_LOCALIZED_APP_PATHS = new Set([
  */
 export function LangLink({ to, ...props }) {
     const lang = useLang();
+    const routing = useContext(LangRoutingContext);
     // If 'to' is a string, prepend language
     const langTo = typeof to === 'string'
         ? (() => {
-            const trimmed = to.replace(/^\//, '');
-            const firstSegment = trimmed.split('/')[0] || '';
-            return NON_LOCALIZED_APP_PATHS.has(firstSegment) ? `/${trimmed}` : `/${lang}/${trimmed}`;
+            const trimmed = (to || '').toString().trim();
+            const normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+            return isNonLocalizedPath(normalized, routing.nonLocalizedPaths)
+                ? normalized
+                : `/${lang}${normalized}`;
         })()
         : to;
     return React.createElement(Link, { ...props, to: langTo });

package/dist/components/LangRouter.d.ts

@@ -4,6 +4,9 @@ interface LangRouterProps {
     defaultLang: string;
     langs: string[];
     navigateRef?: React.MutableRefObject<((path: string) => void) | undefined>;
+    apiBase?: string;
+    apiKey?: string;
+    publicAnonKey?: string;
 }
 /**
  * LangRouter - Drop-in replacement for BrowserRouter that automatically handles language routing
@@ -30,5 +33,5 @@ interface LangRouterProps {
  * - /fr/pricing
  * - etc.
  */
-export declare function LangRouter({ children, defaultLang, langs, navigateRef }: LangRouterProps): React.JSX.Element;
+export declare function LangRouter({ children, defaultLang, langs, navigateRef, apiBase, apiKey, publicAnonKey }: LangRouterProps): React.JSX.Element;
 export {};

package/dist/components/LangRouter.js

@@ -1,17 +1,9 @@
-import React, { useEffect } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { BrowserRouter, Routes, Route, Navigate, Outlet, useLocation, useNavigate } from 'react-router-dom';
 import { LangContext } from '../context/LangContext';
-const NON_LOCALIZED_APP_PATHS = new Set([
-    '/robots.txt',
-    '/sitemap.xml',
-]);
-function isNonLocalizedPath(pathname) {
-    if (NON_LOCALIZED_APP_PATHS.has(pathname))
-        return true;
-    if (pathname.startsWith('/.well-known/'))
-        return true;
-    return /\.(?:png|jpg|jpeg|gif|svg|webp|avif|ico|css|js|map|json|xml|txt|pdf|zip|gz|br|woff2?|ttf|eot)$/i.test(pathname);
-}
+import { LangRoutingContext } from '../context/LangRoutingContext';
+import { isNonLocalizedPath, parseBootstrapInactivePages, parseBootstrapNonLocalizedPaths } from '../utils/nonLocalizedPaths';
+import { logDebug } from '../utils/logger';
 /**
  * NavigateExporter - Internal component that exports navigate function via ref
  */
@@ -27,13 +19,14 @@ function NavigateExporter({ navigateRef }) {
 /**
  * LangGuard - Internal component that validates language and provides it to children
  */
-function LangGuard({ defaultLang, lang }) {
+function LangGuard({ lang, nonLocalizedPaths, defaultLang, }) {
     const location = useLocation();
     // If the URL is language-prefixed but the underlying route is non-localized (e.g. robots/sitemap),
     // redirect to the canonical non-localized path.
     const prefix = `/${lang}`;
     const restPath = location.pathname.startsWith(prefix) ? location.pathname.slice(prefix.length) || '/' : location.pathname;
-    if (isNonLocalizedPath(restPath)) {
+    // Why: only explicit non-localized rules may strip the locale prefix; inactive pages must never affect client routing.
+    if (isNonLocalizedPath(restPath, nonLocalizedPaths)) {
         const nextPath = `${restPath}${location.search}${location.hash}`;
         return React.createElement(Navigate, { to: nextPath, replace: true });
     }
@@ -41,15 +34,24 @@ function LangGuard({ defaultLang, lang }) {
     return (React.createElement(LangContext.Provider, { value: lang },
         React.createElement(Outlet, { context: { lang } })));
 }
-function RedirectToDefaultLang({ defaultLang, children }) {
+function RedirectToDefaultLang({ defaultLang, children, nonLocalizedPaths, routingStatus, }) {
     const location = useLocation();
-    if (isNonLocalizedPath(location.pathname)) {
-        return React.createElement(React.Fragment, null, children);
-    }
-    const nextPath = location.pathname === '/' || location.pathname === ''
-        ? `/${defaultLang}${location.search}${location.hash}`
-        : `/${defaultLang}${location.pathname}${location.search}${location.hash}`;
-    return React.createElement(Navigate, { to: nextPath, replace: true });
+    const navigate = useNavigate();
+    const shouldSkip = isNonLocalizedPath(location.pathname, nonLocalizedPaths);
+    useEffect(() => {
+        if (shouldSkip)
+            return;
+        if (routingStatus === "loading")
+            return;
+        const nextPath = location.pathname === "/" || location.pathname === ""
+            ? `/${defaultLang}${location.search}${location.hash}`
+            : `/${defaultLang}${location.pathname}${location.search}${location.hash}`;
+        const current = `${location.pathname}${location.search}${location.hash}`;
+        if (nextPath === current)
+            return;
+        navigate(nextPath, { replace: true });
+    }, [defaultLang, location.hash, location.pathname, location.search, navigate, routingStatus, shouldSkip]);
+    return React.createElement(React.Fragment, null, children);
 }
 /**
  * LangRouter - Drop-in replacement for BrowserRouter that automatically handles language routing
@@ -76,12 +78,114 @@ function RedirectToDefaultLang({ defaultLang, children }) {
  * - /fr/pricing
  * - etc.
  */
-export function LangRouter({ children, defaultLang, langs, navigateRef }) {
+export function LangRouter({ children, defaultLang, langs, navigateRef, apiBase, apiKey, publicAnonKey }) {
+    const metaKey = typeof document !== "undefined"
+        ? document.querySelector('meta[name="lovalingo-public-anon-key"]')?.content?.trim() || ""
+        : "";
+    const globals = globalThis;
+    const resolvedApiKey = (typeof apiKey === "string" && apiKey.trim().length > 0
+        ? apiKey
+        : typeof publicAnonKey === "string" && publicAnonKey.trim().length > 0
+            ? publicAnonKey
+            : globals.__LOVALINGO_PUBLIC_ANON_KEY__ || globals.__LOVALINGO_API_KEY__ || metaKey || "").trim();
+    const resolvedApiBase = (typeof apiBase === "string" && apiBase.trim().length > 0
+        ? apiBase.trim()
+        : "https://cdn.lovalingo.com");
+    const nonLocalizedStorageKey = useMemo(() => `Lovalingo_non_localized_paths:${resolvedApiKey || "anonymous"}`, [resolvedApiKey]);
+    const inactivePagesStorageKey = useMemo(() => `Lovalingo_inactive_pages:${resolvedApiKey || "anonymous"}`, [resolvedApiKey]);
+    const [nonLocalizedPaths, setNonLocalizedPaths] = useState(() => {
+        if (typeof window === "undefined")
+            return [];
+        if (!resolvedApiKey)
+            return [];
+        try {
+            const raw = localStorage.getItem(nonLocalizedStorageKey);
+            if (!raw)
+                return [];
+            const parsed = JSON.parse(raw);
+            return parseBootstrapNonLocalizedPaths(parsed);
+        }
+        catch {
+            return [];
+        }
+    });
+    const [inactivePages, setInactivePages] = useState(() => {
+        if (typeof window === "undefined")
+            return [];
+        if (!resolvedApiKey)
+            return [];
+        try {
+            const raw = localStorage.getItem(inactivePagesStorageKey);
+            if (!raw)
+                return [];
+            const parsed = JSON.parse(raw);
+            return parseBootstrapInactivePages(parsed);
+        }
+        catch {
+            return [];
+        }
+    });
+    const [routingStatus, setRoutingStatus] = useState(() => {
+        if (!resolvedApiKey)
+            return "unknown";
+        return nonLocalizedPaths.length > 0 || inactivePages.length > 0 ? "ready" : "loading";
+    });
+    const fetchRoutingConfig = useCallback(async () => {
+        if (typeof window === "undefined")
+            return;
+        if (!resolvedApiKey)
+            return;
+        const pathParam = window.location.pathname + window.location.search;
+        const requestUrl = `${resolvedApiBase}/functions/v1/bootstrap?key=${encodeURIComponent(resolvedApiKey)}&locale=${encodeURIComponent(defaultLang)}&path=${encodeURIComponent(pathParam)}`;
+        const response = await fetch(requestUrl);
+        const resolvedResponse = response.status === 304 ? await fetch(requestUrl, { cache: "force-cache" }) : response;
+        if (!resolvedResponse.ok)
+            throw new Error(`bootstrap HTTP ${resolvedResponse.status}`);
+        const data = (await resolvedResponse.json());
+        const record = (data || {});
+        return {
+            nonLocalizedPaths: parseBootstrapNonLocalizedPaths(record["non_localized_paths"]),
+            inactivePages: parseBootstrapInactivePages(record["inactive_pages"]),
+        };
+    }, [defaultLang, resolvedApiBase, resolvedApiKey]);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            if (!resolvedApiKey)
+                return;
+            setRoutingStatus((prev) => (prev === "ready" ? prev : "loading"));
+            try {
+                const next = await fetchRoutingConfig();
+                if (cancelled || !next)
+                    return;
+                setNonLocalizedPaths(next.nonLocalizedPaths);
+                setInactivePages(next.inactivePages);
+                setRoutingStatus("ready");
+                try {
+                    localStorage.setItem(nonLocalizedStorageKey, JSON.stringify(next.nonLocalizedPaths));
+                    localStorage.setItem(inactivePagesStorageKey, JSON.stringify(next.inactivePages));
+                }
+                catch {
+                    // ignore
+                }
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                setRoutingStatus("error");
+                logDebug("[Lovalingo] Failed to fetch routing config:", err);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [fetchRoutingConfig, inactivePagesStorageKey, nonLocalizedStorageKey, resolvedApiKey]);
     return (React.createElement(BrowserRouter, null,
         React.createElement(NavigateExporter, { navigateRef: navigateRef }),
-        React.createElement(Routes, null,
-            langs.map((lang) => (React.createElement(Route, { key: lang, path: `${lang}/*`, element: React.createElement(LangGuard, { defaultLang: defaultLang, lang: lang }) },
-                React.createElement(Route, { index: true, element: React.createElement(React.Fragment, null, children) }),
-                React.createElement(Route, { path: "*", element: React.createElement(React.Fragment, null, children) })))),
-            React.createElement(Route, { path: "*", element: React.createElement(RedirectToDefaultLang, { defaultLang: defaultLang }, children) }))));
+        React.createElement(LangRoutingContext.Provider, { value: { defaultLang, nonLocalizedPaths, inactivePages, status: routingStatus } },
+            React.createElement(Routes, null,
+                langs.map((lang) => (React.createElement(Route, { key: lang, path: `${lang}/*`, element: React.createElement(LangGuard, { lang: lang, nonLocalizedPaths: nonLocalizedPaths, defaultLang: defaultLang }) },
+                    React.createElement(Route, { index: true, element: React.createElement(React.Fragment, null, children) }),
+                    React.createElement(Route, { path: "*", element: React.createElement(React.Fragment, null, children) })))),
+                React.createElement(Route, { path: "*", element: React.createElement(RedirectToDefaultLang, { defaultLang: defaultLang, nonLocalizedPaths: nonLocalizedPaths, routingStatus: routingStatus }, children) })))));
 }

package/dist/components/LanguageSwitcher.js

@@ -210,16 +210,18 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
                         React.createElement("span", { style: {
                                 width: '16px',
                                 height: '16px',
-                                borderRadius: '5px',
-                                background: '#6BD63D',
+                                borderRadius: '999px',
+                                overflow: 'hidden',
+                                background: '#DA2576',
                                 display: 'inline-flex',
                                 alignItems: 'center',
                                 justifyContent: 'center',
                                 boxShadow: 'inset 0 0 0 1px rgba(0,0,0,0.25)',
                                 flexShrink: 0,
                             } },
-                            React.createElement("svg", { width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", "aria-hidden": "true" },
-                                React.createElement("path", { d: "M9 5a2 2 0 0 1 2 2v10h8a2 2 0 1 1 0 4H9a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2Z", fill: "#0D0D0D" }))),
+                            React.createElement("svg", { width: "16", height: "16", viewBox: "0 0 512 512", fill: "none", "aria-hidden": "true" },
+                                React.createElement("path", { d: "M215.657 429.489C270.707 422.73 289.644 339.333 278 244.5C266.356 149.667 228.54 79.3089 173.49 86.0682C118.44 92.8275 83.253 175.184 94.8971 270.017C106.541 364.85 160.607 436.248 215.657 429.489Z", stroke: "#FFFFFF", strokeWidth: "44", strokeLinecap: "round", strokeLinejoin: "round" }),
+                                React.createElement("path", { d: "M168.218 408.885C188.661 447.333 263.959 447.277 336.399 408.759C408.84 370.242 450.992 307.849 430.549 269.401C410.106 230.953 334.808 231.009 262.368 269.526C189.927 308.044 147.775 370.437 168.218 408.885Z", stroke: "#FFFFFF", strokeWidth: "44", strokeLinecap: "round", strokeLinejoin: "round" }))),
                         React.createElement("span", null,
                             branding.label || 'Localized by',
                             " ",

package/dist/context/LangRoutingContext.d.ts

@@ -0,0 +1,8 @@
+import type { NonLocalizedPathRule } from "../utils/nonLocalizedPaths";
+export type LangRoutingContextValue = {
+    defaultLang: string;
+    nonLocalizedPaths: NonLocalizedPathRule[];
+    inactivePages: string[];
+    status: "unknown" | "loading" | "ready" | "error";
+};
+export declare const LangRoutingContext: import("react").Context<LangRoutingContextValue>;

package/dist/context/LangRoutingContext.js

@@ -0,0 +1,7 @@
+import { createContext } from "react";
+export const LangRoutingContext = createContext({
+    defaultLang: "",
+    nonLocalizedPaths: [],
+    inactivePages: [],
+    status: "unknown",
+});

package/dist/hooks/useLangNavigate.js

@@ -1,11 +1,8 @@
 import { useNavigate } from 'react-router-dom';
-import { useCallback } from 'react';
+import { useCallback, useContext } from 'react';
 import { useLang } from './useLang';
-//Globally excluded paths.
-const NON_LOCALIZED_APP_PATHS = new Set([
-    'robots.txt',
-    'sitemap.xml',
-]);
+import { LangRoutingContext } from '../context/LangRoutingContext';
+import { isNonLocalizedPath } from '../utils/nonLocalizedPaths';
 /**
  * useLangNavigate - Get a language-aware navigate function
  *
@@ -29,12 +26,15 @@ const NON_LOCALIZED_APP_PATHS = new Set([
 export function useLangNavigate() {
     const navigate = useNavigate();
     const lang = useLang();
+    const routing = useContext(LangRoutingContext);
     return useCallback((path, options) => {
-        const trimmed = path.replace(/^\//, '');
-        const firstSegment = trimmed.split('/')[0] || '';
-        const fullPath = NON_LOCALIZED_APP_PATHS.has(firstSegment)
-            ? `/${trimmed}`
-            : `/${lang}/${trimmed}`;
+        const trimmed = (path || "").toString().trim();
+        if (!trimmed)
+            return;
+        const normalized = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+        const fullPath = isNonLocalizedPath(normalized, routing.nonLocalizedPaths)
+            ? normalized
+            : `/${lang}${normalized}`;
         navigate(fullPath, options);
-    }, [lang, navigate]);
+    }, [lang, navigate, routing.nonLocalizedPaths]);
 }

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * @Lovalingo/Lovalingo - Proprietary Translation Library
  *
- * Copyright (c) 2025 Mertens Advies. All rights reserved.
+ * Copyright (c) 2025 Lovalingo Swiss. All rights reserved.
  *
- * This software is the intellectual property of Mertens Advies.
+ * This software is the intellectual property of Lovalingo Swiss.
  * NOT OPEN SOURCE - All rights reserved.
  *
  * Unauthorized copying, modification, distribution, or use of this software

package/dist/index.js

@@ -1,9 +1,9 @@
 /**
  * @Lovalingo/Lovalingo - Proprietary Translation Library
  *
- * Copyright (c) 2025 Mertens Advies. All rights reserved.
+ * Copyright (c) 2025 Lovalingo Swiss. All rights reserved.
  *
- * This software is the intellectual property of Mertens Advies.
+ * This software is the intellectual property of Lovalingo Swiss.
  * NOT OPEN SOURCE - All rights reserved.
  *
  * Unauthorized copying, modification, distribution, or use of this software

package/dist/utils/api.d.ts

@@ -25,6 +25,15 @@ 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;

package/dist/utils/nonLocalizedPaths.d.ts

@@ -0,0 +1,12 @@
+export type NonLocalizedPathRule = {
+    pattern: string;
+    match_type: "exact" | "prefix" | "regex";
+};
+export declare function isGlobalNonLocalizedPath(pathname: string): boolean;
+export declare function matchesNonLocalizedRules(pathname: string, rules: NonLocalizedPathRule[]): boolean;
+export declare function isNonLocalizedPath(pathname: string, rules: NonLocalizedPathRule[]): boolean;
+export declare function stripLocalePrefix(pathname: string, locales: string[]): string;
+export declare function parseBootstrapNonLocalizedPaths(value: unknown): NonLocalizedPathRule[];
+export declare function parseBootstrapInactivePages(value: unknown): string[];
+export declare function matchesRouteTemplate(pathname: string, template: string): boolean;
+export declare function isInactivePagePath(pathname: string, inactivePages: string[]): boolean;

package/dist/utils/nonLocalizedPaths.js

@@ -0,0 +1,136 @@
+const GLOBAL_NON_LOCALIZED_APP_PATHS = new Set(["/robots.txt", "/sitemap.xml"]);
+export function isGlobalNonLocalizedPath(pathname) {
+    const input = (pathname || "").toString();
+    if (!input.startsWith("/"))
+        return false;
+    if (GLOBAL_NON_LOCALIZED_APP_PATHS.has(input))
+        return true;
+    if (input.startsWith("/.well-known/"))
+        return true;
+    return /\.(?:png|jpg|jpeg|gif|svg|webp|avif|ico|css|js|map|json|xml|txt|pdf|zip|gz|br|woff2?|ttf|eot)$/i.test(input);
+}
+export function matchesNonLocalizedRules(pathname, rules) {
+    const input = (pathname || "").toString();
+    if (!input.startsWith("/"))
+        return false;
+    if (!Array.isArray(rules) || rules.length === 0)
+        return false;
+    for (const rule of rules) {
+        const pattern = typeof rule?.pattern === "string" ? rule.pattern : "";
+        const matchType = rule?.match_type;
+        if (!pattern)
+            continue;
+        if (matchType === "exact") {
+            if (input === pattern)
+                return true;
+            continue;
+        }
+        if (matchType === "prefix") {
+            if (input === pattern)
+                return true;
+            const normalizedPrefix = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+            if (!normalizedPrefix || normalizedPrefix === "/")
+                return true;
+            if (input.startsWith(`${normalizedPrefix}/`))
+                return true;
+            continue;
+        }
+        if (matchType === "regex") {
+            try {
+                if (new RegExp(pattern).test(input))
+                    return true;
+            }
+            catch {
+                // ignore invalid regex rules
+            }
+        }
+    }
+    return false;
+}
+export function isNonLocalizedPath(pathname, rules) {
+    return isGlobalNonLocalizedPath(pathname) || matchesNonLocalizedRules(pathname, rules);
+}
+export function stripLocalePrefix(pathname, locales) {
+    const input = (pathname || "").toString();
+    if (!input.startsWith("/"))
+        return input;
+    const parts = input.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return "/";
+    const first = parts[0] || "";
+    if (!first || !Array.isArray(locales) || !locales.includes(first))
+        return input;
+    const rest = `/${parts.slice(1).join("/")}`;
+    return rest === "" ? "/" : rest;
+}
+export function parseBootstrapNonLocalizedPaths(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const row of value) {
+        if (!row || typeof row !== "object")
+            continue;
+        const record = row;
+        const pattern = typeof record.pattern === "string" ? record.pattern.trim() : "";
+        const match_type = typeof record.match_type === "string" ? record.match_type.trim() : "";
+        if (!pattern)
+            continue;
+        if (match_type !== "exact" && match_type !== "prefix" && match_type !== "regex")
+            continue;
+        out.push({ pattern, match_type: match_type });
+    }
+    return out;
+}
+export function parseBootstrapInactivePages(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const row of value) {
+        if (typeof row === "string") {
+            const pagePath = row.trim();
+            if (pagePath && pagePath.startsWith("/"))
+                out.push(pagePath);
+            continue;
+        }
+        if (!row || typeof row !== "object")
+            continue;
+        const record = row;
+        const pagePath = typeof record.page_path === "string" ? record.page_path.trim() : "";
+        if (!pagePath || !pagePath.startsWith("/"))
+            continue;
+        out.push(pagePath);
+    }
+    return out;
+}
+function escapeRegexLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function matchesRouteTemplate(pathname, template) {
+    const input = (pathname || "").toString();
+    const pattern = (template || "").toString();
+    if (!input.startsWith("/") || !pattern.startsWith("/"))
+        return false;
+    if (input === pattern)
+        return true;
+    // Convert "/dashboard/projects/:id/pages" or "/use-cases/[slug]" into a safe regex.
+    const parts = pattern.split("/").filter(Boolean);
+    const regexParts = parts.map((part) => {
+        if (part === "*")
+            return ".*";
+        if (part.startsWith(":"))
+            return "[^/]+";
+        if (part.startsWith("[") && part.endsWith("]"))
+            return "[^/]+";
+        return escapeRegexLiteral(part);
+    });
+    const regex = new RegExp(`^/${regexParts.join("/")}$`);
+    return regex.test(input);
+}
+export function isInactivePagePath(pathname, inactivePages) {
+    const input = (pathname || "").toString();
+    if (!input.startsWith("/"))
+        return false;
+    if (!Array.isArray(inactivePages) || inactivePages.length === 0)
+        return false;
+    return inactivePages.some((pattern) => matchesRouteTemplate(input, pattern));
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.3.2";
+export declare const VERSION = "0.5.4";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.3.2";
+export const VERSION = "0.5.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovalingo/lovalingo",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "React translation runtime with i18n routing, deterministic bundles + DOM rules, and zero-flash rendering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "lovable",
     "vibe-coded"
   ],
-  "author": "Mertens Advies",
+  "author": "Lovalingo Swiss",
   "license": "UNLICENSED",
   "private": false,
   "peerDependencies": {