@lovalingo/lovalingo 0.5.5 → 0.5.7

package/dist/hooks/provider/useNavigationPrefetch.js

@@ -0,0 +1,81 @@
+import { useEffect } from "react";
+import { processPath } from "../../utils/pathNormalizer";
+export function useNavigationPrefetch({ resolvedApiKey, apiBase, defaultLocale, locale, routing, allLocales, enhancedPathConfig, }) {
+    // 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)
+            return;
+        if (typeof window === "undefined" || typeof document === "undefined")
+            return;
+        const connection = navigator?.connection;
+        if (connection?.saveData)
+            return;
+        if (typeof connection?.effectiveType === "string" && /(^|-)2g$/.test(connection.effectiveType))
+            return;
+        const prefetched = new Set();
+        // Why: cap speculative requests to avoid flooding the network on pages with many links.
+        const maxPrefetch = 40;
+        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 pickLocaleForUrl = (url) => {
+            if (routing === "path") {
+                const segment = url.pathname.split("/")[1] || "";
+                if (segment && allLocales.includes(segment))
+                    return segment;
+                return locale;
+            }
+            const q = url.searchParams.get("t") || url.searchParams.get("locale");
+            if (q && allLocales.includes(q))
+                return q;
+            return locale;
+        };
+        const onIntent = (event) => {
+            if (prefetched.size >= maxPrefetch)
+                return;
+            const target = event.target;
+            const anchor = target?.closest?.("a[href]");
+            if (!anchor)
+                return;
+            const href = anchor.getAttribute("href") || "";
+            if (!href || /^(?:#|mailto:|tel:|sms:|javascript:)/i.test(href))
+                return;
+            let url;
+            try {
+                url = new URL(href, window.location.origin);
+            }
+            catch {
+                return;
+            }
+            if (url.origin !== window.location.origin)
+                return;
+            if (isAssetPath(url.pathname))
+                return;
+            const targetLocale = pickLocaleForUrl(url);
+            if (!targetLocale || targetLocale === defaultLocale)
+                return;
+            const normalizedPath = processPath(url.pathname, enhancedPathConfig);
+            const key = `${targetLocale}:${normalizedPath}`;
+            if (prefetched.has(key))
+                return;
+            prefetched.add(key);
+            const pathParam = `${url.pathname}${url.search}`;
+            const bootstrapUrl = `${apiBase}/functions/v1/bootstrap?key=${encodeURIComponent(resolvedApiKey)}&locale=${encodeURIComponent(targetLocale)}&path=${encodeURIComponent(pathParam)}`;
+            const bundleUrl = `${apiBase}/functions/v1/bundle?key=${encodeURIComponent(resolvedApiKey)}&locale=${encodeURIComponent(targetLocale)}&path=${encodeURIComponent(pathParam)}`;
+            void fetch(bootstrapUrl, { cache: "force-cache" }).catch(() => undefined);
+            void fetch(bundleUrl, { cache: "force-cache" }).catch(() => undefined);
+        };
+        document.addEventListener("pointerover", onIntent, { passive: true });
+        document.addEventListener("touchstart", onIntent, { passive: true });
+        document.addEventListener("focusin", onIntent);
+        return () => {
+            document.removeEventListener("pointerover", onIntent);
+            document.removeEventListener("touchstart", onIntent);
+            document.removeEventListener("focusin", onIntent);
+        };
+    }, [allLocales, apiBase, defaultLocale, enhancedPathConfig, locale, resolvedApiKey, routing]);
+}

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

@@ -0,0 +1,10 @@
+import type React from "react";
+import type { LovalingoAPI } from "../../utils/api";
+type UsePageviewTrackingOptions = {
+    apiRef: React.MutableRefObject<LovalingoAPI>;
+    resolvedApiKey: string;
+};
+export declare function usePageviewTracking({ apiRef, resolvedApiKey }: UsePageviewTrackingOptions): {
+    trackPageviewOnce: (path: string) => void;
+};
+export {};

package/dist/hooks/provider/usePageviewTracking.js

@@ -0,0 +1,44 @@
+import { useCallback, useEffect, useRef } from "react";
+import { getCriticalFingerprint } from "../../utils/markerEngine";
+export function usePageviewTracking({ apiRef, resolvedApiKey }) {
+    const lastPageviewRef = useRef("");
+    const lastPageviewFingerprintRef = useRef("");
+    const pageviewFingerprintTimeoutRef = useRef(null);
+    const pageviewFingerprintRetryTimeoutRef = useRef(null);
+    useEffect(() => {
+        lastPageviewRef.current = "";
+        lastPageviewFingerprintRef.current = "";
+    }, [resolvedApiKey]);
+    const trackPageviewOnce = useCallback((path) => {
+        const next = (path || "").toString();
+        if (!next)
+            return;
+        if (lastPageviewRef.current === next)
+            return;
+        lastPageviewRef.current = next;
+        apiRef.current.trackPageview(next);
+        const trySendFingerprint = () => {
+            if (typeof window === "undefined")
+                return;
+            const markersReady = window.__lovalingoMarkersReady === true;
+            if (!markersReady)
+                return;
+            const fp = getCriticalFingerprint();
+            if (!fp || fp.critical_count <= 0)
+                return;
+            const signature = `${next}|${fp.critical_hash}|${fp.critical_count}`;
+            if (lastPageviewFingerprintRef.current === signature)
+                return;
+            lastPageviewFingerprintRef.current = signature;
+            apiRef.current.trackPageview(next, fp);
+        };
+        if (pageviewFingerprintTimeoutRef.current != null)
+            window.clearTimeout(pageviewFingerprintTimeoutRef.current);
+        if (pageviewFingerprintRetryTimeoutRef.current != null)
+            window.clearTimeout(pageviewFingerprintRetryTimeoutRef.current);
+        // Why: wait briefly for markers/content to settle before computing a critical fingerprint for change detection.
+        pageviewFingerprintTimeoutRef.current = window.setTimeout(trySendFingerprint, 800);
+        pageviewFingerprintRetryTimeoutRef.current = window.setTimeout(trySendFingerprint, 2000);
+    }, [apiRef]);
+    return { trackPageviewOnce };
+}

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

@@ -0,0 +1,5 @@
+export declare const PREHIDE_FAILSAFE_MS = 1700;
+export declare function usePrehide(): {
+    enablePrehide: (bgColor: string) => void;
+    disablePrehide: () => void;
+};

package/dist/hooks/provider/usePrehide.js

@@ -0,0 +1,72 @@
+import { useCallback, useEffect, useRef } from "react";
+// Why: avoid long blank screens on blocked/untranslated routes by always revealing the original page quickly.
+export const PREHIDE_FAILSAFE_MS = 1700;
+export function usePrehide() {
+    const prehideStateRef = useRef({
+        active: false,
+        timeoutId: null,
+        startedAtMs: null,
+        prevHtmlVisibility: "",
+        prevBodyVisibility: "",
+        prevHtmlBg: "",
+        prevBodyBg: "",
+    });
+    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;
+        const html = document.documentElement;
+        const body = document.body;
+        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 || "";
+            state.prevBodyBg = body.style.backgroundColor || "";
+        }
+        html.style.visibility = "hidden";
+        body.style.visibility = "hidden";
+        if (bgColor) {
+            html.style.backgroundColor = bgColor;
+            body.style.backgroundColor = bgColor;
+        }
+        if (state.timeoutId != null) {
+            return;
+        }
+        // Why: avoid a "perma-hide" when navigation events repeatedly re-trigger prehide and keep extending the timeout.
+        state.timeoutId = window.setTimeout(() => forceDisablePrehide(), PREHIDE_FAILSAFE_MS);
+    }, [forceDisablePrehide]);
+    const disablePrehide = forceDisablePrehide;
+    useEffect(() => {
+        return () => disablePrehide();
+    }, [disablePrehide]);
+    return { enablePrehide, disablePrehide };
+}

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

@@ -0,0 +1,7 @@
+type UseSitemapLinkTagOptions = {
+    enabled: boolean;
+    resolvedApiKey: string;
+    isSeoActive: () => boolean;
+};
+export declare function useSitemapLinkTag({ enabled, resolvedApiKey, isSeoActive }: UseSitemapLinkTagOptions): void;
+export {};

package/dist/hooks/provider/useSitemapLinkTag.js

@@ -0,0 +1,28 @@
+import { useEffect } from "react";
+export function useSitemapLinkTag({ enabled, resolvedApiKey, isSeoActive }) {
+    // Auto-inject sitemap link tag
+    useEffect(() => {
+        if (enabled && resolvedApiKey && isSeoActive()) {
+            // Prefer same-origin /sitemap.xml so crawlers discover the canonical sitemap URL.
+            // Reminder: /sitemap.xml should be published by the host app (recommended: build-time copy from Lovalingo CDN).
+            const sitemapUrl = `${window.location.origin}/sitemap.xml`;
+            // Check if link already exists to avoid duplicates
+            const existingLink = document.querySelector(`link[rel="sitemap"][href="${sitemapUrl}"]`);
+            if (existingLink)
+                return;
+            // Create and inject link tag
+            const link = document.createElement("link");
+            link.rel = "sitemap";
+            link.type = "application/xml";
+            link.href = sitemapUrl;
+            document.head.appendChild(link);
+            // Cleanup on unmount
+            return () => {
+                const linkToRemove = document.querySelector(`link[rel="sitemap"][href="${sitemapUrl}"]`);
+                if (linkToRemove) {
+                    document.head.removeChild(linkToRemove);
+                }
+            };
+        }
+    }, [enabled, resolvedApiKey, isSeoActive]);
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.5.5";
+export declare const VERSION = "0.5.6";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.5.5";
+export const VERSION = "0.5.6";

package/package.json

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