@lovalingo/lovalingo 0.5.23 → 0.5.25

package/dist/components/LovalingoProvider.js

@@ -556,7 +556,6 @@ navigateRef, // For path mode routing
         void (async () => {
             if (!allLocales.includes(newLocale))
                 return;
-            const previousLocale = locale; // Capture current locale before switching
             // Save to localStorage
             try {
                 localStorage.setItem(LOCALE_STORAGE_KEY, newLocale);
@@ -567,48 +566,39 @@ navigateRef, // For path mode routing
             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".
-                    setLocaleState(newLocale);
-                    isNavigatingRef.current = false;
-                    return;
-                }
-                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('/');
-                const newPath = `/${newLocale}${basePath ? '/' + basePath : ''}${window.location.search}${window.location.hash}`;
-                // Prefer React Router navigation when available, but gracefully fallback for non-React-Router apps
-                const navigate = navigateRef?.current;
-                if (navigate) {
-                    navigate(newPath);
+                    nextUrl = window.location.href;
                 }
                 else {
-                    try {
-                        window.history.pushState({}, '', newPath);
-                    }
-                    catch {
-                        window.location.assign(newPath);
+                    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);
-                window.history.pushState({}, '', url.toString());
+                nextUrl = url.toString();
             }
-            setLocaleState(newLocale);
-            await loadData(newLocale, previousLocale);
+            if (!nextUrl)
+                nextUrl = window.location.href;
+            window.location.assign(nextUrl);
+            return;
         })().finally(() => {
             isInternalNavigationRef.current = false;
         });
-    }, [allLocales, defaultLocale, locale, routing, loadData, navigateRef, routingConfig.nonLocalizedPaths]);
+    }, [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);

package/dist/hooks/provider/useStringMissReporting.js

@@ -6,6 +6,29 @@ import { isNonLocalizedPath, stripLocalePrefix } from "../../utils/nonLocalizedP
 const MISS_SCAN_THROTTLE_MS = 600;
 // Why: allow large pages to report plenty of misses while keeping payloads bounded.
 const MISS_MAX_PER_PAGE = 500;
+function looksLike404Page() {
+    if (typeof document === "undefined")
+        return false;
+    // 1. Meta tag (Explicit opt-in for SPAs)
+    const meta = document.querySelector('meta[name="lovalingo:status"]');
+    if (meta && meta.getAttribute("content") === "404")
+        return true;
+    // 2. Title Heuristics
+    const title = (document.title || "").toLowerCase();
+    // Why: detect common 404 title patterns to avoid reporting misses on ghost pages.
+    if (/page not found|seite nicht gefunden|article not found|error 404|page missing|does not exist/.test(title))
+        return true;
+    // 3. H1 Heuristics
+    const h1 = document.querySelector("h1");
+    if (h1) {
+        const txt = (h1.innerText || "").toLowerCase();
+        if (/page not found|seite nicht gefunden|article not found|error 404/.test(txt))
+            return true;
+        if (txt.includes("404") && txt.length < 50)
+            return true;
+    }
+    return false;
+}
 export function useStringMissReporting(args) {
     const pendingRef = useRef(new Set());
     const seenRef = useRef(new Set());
@@ -18,6 +41,8 @@ export function useStringMissReporting(args) {
     const shouldSkip = useCallback(() => {
         if (typeof window === "undefined" || typeof document === "undefined")
             return true;
+        if (looksLike404Page())
+            return true;
         const disableLiveMisses = Boolean(window.__lovalingoDisableMisses);
         if (disableLiveMisses)
             return true;

package/dist/utils/api.js

@@ -1,5 +1,6 @@
 import { warnDebug, errorDebug } from './logger';
 const OK_HTTP_STATUSES = new Set([200, 201]);
+const NOT_FOUND_TITLE_HINTS = /404|not found|page not found|page missing|does not exist|error 404/i;
 function getNavigationResponseStatus() {
     if (typeof performance === "undefined" || typeof performance.getEntriesByType !== "function")
         return null;
@@ -19,6 +20,19 @@ function isOkHttpStatus(status) {
         return true;
     return OK_HTTP_STATUSES.has(status);
 }
+function looksLikeNotFoundDocument() {
+    if (typeof document === "undefined")
+        return false;
+    const title = (document.title || "").toString().trim().toLowerCase();
+    if (title && NOT_FOUND_TITLE_HINTS.test(title))
+        return true;
+    const bodyText = (document.body?.textContent || "").toString().slice(0, 2000).toLowerCase();
+    if (!bodyText)
+        return false;
+    const has404 = /\b404\b/.test(bodyText);
+    const hasNotFound = /not found|page not found|page missing|does not exist|error 404/.test(bodyText);
+    return has404 && hasNotFound;
+}
 function normalizeApiBase(raw) {
     const input = (raw || "").toString().trim();
     if (!input)
@@ -168,6 +182,9 @@ export class LovalingoAPI {
             const status = getNavigationResponseStatus();
             if (!isOkHttpStatus(status))
                 return;
+            // Why: avoid tracking SPA soft-404s (HTTP 200 + "not found" content) so ghost pages don't reappear.
+            if (looksLikeNotFoundDocument())
+                return;
             const params = new URLSearchParams();
             params.set("key", this.apiKey);
             params.set("path", pathOrUrl);
@@ -200,6 +217,9 @@ export class LovalingoAPI {
             if (!isOkHttpStatus(status)) {
                 return { ignored: true, reason: "http_status" };
             }
+            if (looksLikeNotFoundDocument()) {
+                return { ignored: true, reason: "soft_404" };
+            }
             const pathParam = this.buildPathParam(opts?.pathOrUrl);
             const response = await fetch(`${this.apiBase}/functions/v1/misses`, {
                 method: "POST",

package/package.json

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