npm - @lovalingo/lovalingo - Versions diffs - 0.0.29 → 0.1.1 - Mend

@lovalingo/lovalingo 0.0.29 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md +72 -175
package/dist/components/AixsterProvider.js +19 -11
package/dist/components/LanguageSwitcher.d.ts +1 -0
package/dist/components/LanguageSwitcher.js +41 -20
package/dist/types.d.ts +1 -3
package/dist/utils/api.js +7 -6
package/dist/utils/logger.d.ts +3 -0
package/dist/utils/logger.js +23 -0
package/dist/utils/markerEngine.d.ts +21 -0
package/dist/utils/markerEngine.js +279 -0
package/dist/utils/pathNormalizer.js +2 -1
package/dist/utils/translator.js +23 -21
package/dist/version.d.ts +1 -1
package/dist/version.js +1 -1
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -1,8 +1,18 @@
-# @lovalingo/lovalingo — Best Weglot & i18n alternative for Vibe Coders, Lovable, v0, Emergent & more
+# @lovalingo/lovalingo
-Seamless website translation for React (React Router) and Next.js with **zero‑flash rendering**, **automatic language routing**, and **SEO signals (canonical + hreflang)** — built for fast iteration in AI/vibe‑coding workflows.
+Lovalingo is a translation runtime for React (React Router) and Next.js that loads **pre-built artifacts** (JSON bundles + DOM rules) from the Lovalingo backend and applies them with **zero-flash**.
-If you ship with Lovable, v0, Emergent, Vite, Claude Code or similar tools, Lovalingo is the fastest way to production‑grade i18n without Weglot overhead.
+It does **not** generate translations in the browser.
+## How it works (high level)
+1. Your app renders normally (source language).
+2. Lovalingo loads the current locale’s bundle from the backend.
+3. The runtime mutates the DOM before paint (and keeps up with route changes + dynamic content).
+4. Optional: Lovalingo fetches DOM rules (CSS/JS/DOM patches) to fix edge cases (hidden UI, wrapping, etc.).
+5. Optional SEO: Lovalingo updates `<head>` (canonical + hreflang + basic meta) using `seo-bundle`.
+All artifacts are produced server-side by the pipeline (render → audit → deterministic translate → optional fix loop).
 ## Installation
@@ -10,108 +20,75 @@ If you ship with Lovable, v0, Emergent, Vite, Claude Code or similar tools, Lova
 npm install @lovalingo/lovalingo react-router-dom
 ```
-## Quick Start
+## React Router
-Lovalingo **erzeugt Übersetzungen nicht im Browser**. Die Runtime lädt fertige Artefakte (JSON‑Bundle + DOM‑Rules) vom Backend; die server‑seitige Pipeline rendert Seiten, extrahiert Marker/Strings, übersetzt deterministisch und erzeugt bei Bedarf DOM‑Fixes.
-### Option 1: Path Mode (Recommended - Automatic Language URLs)
-**One-line setup** that automatically handles language routing like `/en/pricing`, `/fr/pricing`, `/de/pricing`:
+### Query mode (default)
 ```tsx
-import { LangRouter, LovalingoProvider } from '@lovalingo/lovalingo';
-import { Routes, Route } from 'react-router-dom';
-import { useRef } from 'react';
-function App() {
-  const navigateRef = useRef();
+import { BrowserRouter } from "react-router-dom";
+import { LovalingoProvider } from "@lovalingo/lovalingo";
+export function App() {
   return (
-    <LangRouter defaultLang="en" langs={['en', 'fr', 'de', 'es']} navigateRef={navigateRef}>
+    <BrowserRouter>
       <LovalingoProvider
         publicAnonKey="aix_your_public_anon_key"
         defaultLocale="en"
-        locales={['en', 'fr', 'de', 'es']}
-        routing="path"
-        navigateRef={navigateRef}
+        locales={["en", "de", "fr"]}
+        routing="query"
       >
-        <Routes>
-          {/* No language prefix needed! */}
-          <Route path="/" element={<Home />} />
-          <Route path="home" element={<Home />} />
-          <Route path="pricing" element={<Pricing />} />
-          <Route path="about" element={<About />} />
-        </Routes>
+        <YourApp />
       </LovalingoProvider>
-    </LangRouter>
+    </BrowserRouter>
   );
 }
 ```
-**Important:** Pass the same `navigateRef` to both `<LangRouter>` and `<LovalingoProvider>` for proper URL synchronization.
+URLs look like: `/pricing?t=de`.
-**Common error (React Router v6):** If you see `LovalingoProvider is not a <Route> component`, you’re either:
-- on an older `@lovalingo/lovalingo` version (upgrade), or
-- you accidentally placed `<LovalingoProvider>` directly inside `<Routes>`.
+### Path mode (SEO-friendly URLs)
-Correct:
 ```tsx
-<LovalingoProvider ...>
-  <Routes>...</Routes>
-</LovalingoProvider>
-```
-Incorrect:
-```tsx
-<Routes>
-  <LovalingoProvider ... />
-</Routes>
-```
-URLs automatically work as:
-- `/en/`, `/en/home`, `/en/pricing`, `/en/about`
-- `/fr/`, `/fr/home`, `/fr/pricing`, `/fr/about`
-- `/de/`, `/de/home`, `/de/pricing`, `/de/about`
+import { useRef } from "react";
+import { Routes, Route } from "react-router-dom";
+import { LangRouter, LovalingoProvider } from "@lovalingo/lovalingo";
-### Option 2: Query Mode (Simple - Query Parameters)
+export function App() {
+  const navigateRef = useRef<((path: string) => void) | undefined>(undefined);
-Use query parameters like `/pricing?t=fr`:
-```tsx
-import { LovalingoProvider } from '@lovalingo/lovalingo';
-import { BrowserRouter } from 'react-router-dom';
-function App() {
   return (
-    <BrowserRouter>
+    <LangRouter defaultLang="en" langs={["en", "de", "fr"]} navigateRef={navigateRef}>
       <LovalingoProvider
         publicAnonKey="aix_your_public_anon_key"
         defaultLocale="en"
-        locales={['en', 'de', 'fr', 'es']}
-        routing="query"
+        locales={["en", "de", "fr"]}
+        routing="path"
+        navigateRef={navigateRef}
       >
-        <YourApp />
+        <Routes>
+          <Route path="/" element={<Home />} />
+          <Route path="pricing" element={<Pricing />} />
+          <Route path="about" element={<About />} />
+        </Routes>
       </LovalingoProvider>
-    </BrowserRouter>
+    </LangRouter>
   );
 }
 ```
-### Next.js
+URLs look like: `/de/pricing`.
+## Next.js (App Router)
 ```tsx
 // app/layout.tsx
-import { LovalingoProvider } from '@lovalingo/lovalingo';
+import { LovalingoProvider } from "@lovalingo/lovalingo";
-export default function RootLayout({ children }) {
+export default function RootLayout({ children }: { children: React.ReactNode }) {
   return (
     <html>
       <body>
-        <LovalingoProvider
-          publicAnonKey="aix_your_public_anon_key"
-          defaultLocale="en"
-          locales={['en', 'de', 'fr', 'es']}
-        >
+        <LovalingoProvider publicAnonKey="aix_your_public_anon_key" defaultLocale="en" locales={["en", "de", "fr"]}>
           {children}
         </LovalingoProvider>
       </body>
@@ -120,124 +97,27 @@ export default function RootLayout({ children }) {
 }
 ```
-## Configuration
-```tsx
-<LovalingoProvider
-  publicAnonKey="aix_xxx"             // Required: Your Lovalingo Public Anon Key (safe to expose)
-  defaultLocale="en"                  // Required: Source language
-  locales={['en', 'de', 'fr']}        // Required: Supported languages
-  apiBase="https://..."               // Optional: Custom API endpoint
-  routing="query"                     // Optional: 'query' | 'path' (default: 'query')
-  autoPrefixLinks={true}              // Optional (path mode): keep locale when the app renders absolute links like "/pricing"
-  switcherPosition="bottom-right"     // Optional: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left'
-  switcherOffsetY={20}                // Optional: Vertical offset in pixels
-  editMode={false}                    // Optional: Enable edit mode
-  editKey="KeyE"                      // Optional: Keyboard shortcut for edit mode
-  mode="dom"                          // Optional: 'dom' | 'context' (default: 'dom')
-  pathNormalization={{ enabled: true }}// Optional: normalize paths for stable translation keys (default: enabled)
-  seo={true}                          // Optional: auto canonical + hreflang + sitemap link (default: true)
-  sitemap={true}                      // Optional: auto-inject sitemap link (default: true)
->
-  {children}
-</LovalingoProvider>
-```
-### Optional: Inject via `index.html`
+## SEO (canonical + hreflang + meta)
-If your tooling prefers you to avoid hardcoding the key inside JSX, you can inject it at runtime:
-```html
-<meta name="lovalingo-public-anon-key" content="aix_xxx" />
-<script>
-  window.__LOVALINGO_PUBLIC_ANON_KEY__ = "aix_xxx";
-</script>
-```
-Then you may omit `publicAnonKey` and Lovalingo will read it from the meta tag or `window.__LOVALINGO_PUBLIC_ANON_KEY__`.
-### Routing Modes
-- **`query`** (default): Language in query parameter `/pricing?t=fr`
-  - Use with standard React Router setup
-  - No URL structure changes needed
-- **`path`**: Language in URL path `/fr/pricing`
-  - Use with `<LangRouter>` wrapper
-  - Automatic language routing
-  - SEO-optimized URLs
-  - Non-localized by default: `/auth`, `/login`, `/signup` (no `/:lang/` prefix)
-  - Examples:
-    - `/en/` → English home
-    - `/de/pricing` → German pricing
-    - `/fr/about` → French about
-## Path Mode Helpers (v0.0.x+)
-### LangLink - Language-Aware Links
+Enabled by default. Disable if you already manage `<head>` yourself:
 ```tsx
-import { LangLink } from '@lovalingo/lovalingo';
-function Navigation() {
-  return (
-    <nav>
-      {/* Automatically becomes /en/pricing or /fr/pricing */}
-      <LangLink to="pricing">Pricing</LangLink>
-      <LangLink to="about">About</LangLink>
-    </nav>
-  );
-}
+<LovalingoProvider seo={false} ... />
 ```
-### useLang - Get Current Language
+## Sitemap link tag
-```tsx
-import { useLang } from '@lovalingo/lovalingo';
-function MyComponent() {
-  const lang = useLang(); // 'en', 'fr', 'de', etc.
-  return <div>Current language: {lang}</div>;
-}
-```
-### useLangNavigate - Programmatic Navigation
+By default Lovalingo injects `<link rel="sitemap" href="/sitemap.xml">` for discovery. Disable it:
 ```tsx
-import { useLangNavigate } from '@lovalingo/lovalingo';
-function MyComponent() {
-  const navigate = useLangNavigate();
-  const goToPricing = () => {
-    navigate('pricing'); // Goes to /en/pricing or /fr/pricing automatically
-  };
-  return <button onClick={goToPricing}>View Pricing</button>;
-}
+<LovalingoProvider sitemap={false} ... />
 ```
-## Core Hooks
+You still need to serve `/sitemap.xml` on your own domain (recommended: reverse-proxy to Lovalingo’s `generate-sitemap` endpoint).
-### useLovalingo
-Access locale state and switching:
-```tsx
-import { useLovalingo } from '@lovalingo/lovalingo';
-function MyComponent() {
-  const { locale, setLocale, isLoading, config } = useLovalingo();
-  return (
-    <button onClick={() => setLocale('de')}>
-      Switch to German
-    </button>
-  );
-}
-```
+## License
-### useLovalingoTranslate
+Commercial license (not open source). See `react-package/LICENSE`.
 Manual translation control:
@@ -295,6 +175,23 @@ function MyComponent() {
 - ✅ RTL ready: automatically sets `<html dir="rtl">` for `ar/he/fa/ur`
 - ✅ Optional Context Mode: `<AutoTranslate>` with hash-based caching for React text nodes
+## Language Switcher
+Lovalingo includes a floating language switcher.
+```tsx
+<LovalingoProvider
+  publicAnonKey="aix_xxx"
+  defaultLocale="en"
+  locales={["en", "de", "fr"]}
+  switcherPosition="bottom-right"
+  switcherOffsetY={20}
+  switcherTheme="light" // "dark" | "light" (default: "dark")
+>
+  <App />
+</LovalingoProvider>
+```
 ## SEO (Canonical + hreflang)
 Lovalingo can keep `<head>` SEO signals in sync with the active locale:

package/dist/components/AixsterProvider.js CHANGED Viewed

@@ -3,11 +3,13 @@ import { LovalingoContext } from '../context/LovalingoContext';
 import { LovalingoAPI } from '../utils/api';
 import { Translator } from '../utils/translator';
 import { applyDomRules } from '../utils/domRules';
+import { startMarkerEngine } from '../utils/markerEngine';
+import { logDebug, warnDebug, errorDebug } from '../utils/logger';
 import { LanguageSwitcher } from './LanguageSwitcher';
 import { NavigationOverlay } from './NavigationOverlay';
 const LOCALE_STORAGE_KEY = 'Lovalingo_locale';
 export const LovalingoProvider = ({ children, apiKey: apiKeyProp, publicAnonKey, defaultLocale, locales, apiBase = 'https://leuskvkajliuzalrlwhw.supabase.co', routing = 'query', // Default to query mode (backward compatible)
-autoPrefixLinks = true, autoApplyRules = true, switcherPosition = 'bottom-right', switcherOffsetY = 20, editMode: initialEditMode = false, editKey = 'KeyE', pathNormalization = { enabled: true }, // Enable by default
+autoPrefixLinks = true, autoApplyRules = true, switcherPosition = 'bottom-right', switcherOffsetY = 20, switcherTheme = 'dark', editMode: initialEditMode = false, editKey = 'KeyE', pathNormalization = { enabled: true }, // 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
@@ -73,6 +75,7 @@ navigateRef, // For path mode routing
         autoPrefixLinks,
         switcherPosition,
         switcherOffsetY,
+        switcherTheme,
         editMode: initialEditMode,
         editKey,
         pathNormalization,
@@ -204,9 +207,14 @@ navigateRef, // For path mode routing
             }
         }
         catch (e) {
-            console.warn("[Lovalingo] updateSeoLinks() failed:", e);
+            warnDebug("[Lovalingo] updateSeoLinks() failed:", e);
         }
     }, [isSeoActive]);
+    // 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(() => {
         // 1. Check URL first based on routing mode
@@ -234,7 +242,7 @@ navigateRef, // For path mode routing
         }
         catch (e) {
             // localStorage might be unavailable (SSR, private browsing)
-            console.warn('localStorage not available:', e);
+            warnDebug('localStorage not available:', e);
         }
         // 3. Default locale
         return defaultLocale;
@@ -282,7 +290,7 @@ navigateRef, // For path mode routing
         const cachedDomRules = domRulesCacheRef.current.get(cacheKey);
         if (cachedEntry && cachedExclusions) {
             // CACHE HIT - Use cached data immediately (FAST!)
-            console.log(`[Lovalingo] Using cached translations for ${targetLocale} on ${currentPath}`);
+            logDebug(`[Lovalingo] Using cached translations for ${targetLocale} on ${currentPath}`);
             translatorRef.current.setTranslations(cachedEntry.translations);
             translatorRef.current.setExclusions(cachedExclusions);
             if (mode === 'dom') {
@@ -304,7 +312,7 @@ navigateRef, // For path mode routing
                 if (isNavigatingRef.current) {
                     return;
                 }
-                console.log(`[Lovalingo] 🔄 Retry scan for late-rendering content`);
+                logDebug(`[Lovalingo] 🔄 Retry scan for late-rendering content`);
                 if (mode === 'dom') {
                     translatorRef.current.translateDOM();
                 }
@@ -320,11 +328,11 @@ navigateRef, // For path mode routing
             return;
         }
         // CACHE MISS - Fetch from API
-        console.log(`[Lovalingo] Fetching translations for ${targetLocale} on ${currentPath}`);
+        logDebug(`[Lovalingo] Fetching translations for ${targetLocale} on ${currentPath}`);
         setIsLoading(true);
         try {
             if (previousLocale && previousLocale !== defaultLocale) {
-                console.log(`[Lovalingo] Switching from ${previousLocale} to ${targetLocale}`);
+                logDebug(`[Lovalingo] Switching from ${previousLocale} to ${targetLocale}`);
             }
             const [bundle, exclusions, domRules] = await Promise.all([
                 apiRef.current.fetchBundle(targetLocale),
@@ -362,7 +370,7 @@ navigateRef, // For path mode routing
                 if (isNavigatingRef.current) {
                     return;
                 }
-                console.log(`[Lovalingo] 🔄 Retry scan for late-rendering content`);
+                logDebug(`[Lovalingo] 🔄 Retry scan for late-rendering content`);
                 if (mode === "dom") {
                     translatorRef.current.translateDOM();
                 }
@@ -376,7 +384,7 @@ navigateRef, // For path mode routing
             }
         }
         catch (error) {
-            console.error('Error loading translations:', error);
+            errorDebug('Error loading translations:', error);
             if (showOverlay)
                 setIsNavigationLoading(false);
         }
@@ -396,7 +404,7 @@ navigateRef, // For path mode routing
                 localStorage.setItem(LOCALE_STORAGE_KEY, newLocale);
             }
             catch (e) {
-                console.warn('Failed to save locale to localStorage:', e);
+                warnDebug('Failed to save locale to localStorage:', e);
             }
             isInternalNavigationRef.current = true;
             // Show navigation overlay immediately (only when a non-default locale is involved)
@@ -788,7 +796,7 @@ 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, branding: entitlements?.brandingRequired
+        React.createElement(LanguageSwitcher, { locales: allLocales, currentLocale: locale, onLocaleChange: setLocale, position: switcherPosition, offsetY: switcherOffsetY, theme: switcherTheme, branding: entitlements?.brandingRequired
                 ? { required: true, href: "https://lovalingo.com" }
                 : undefined }),
         React.createElement(NavigationOverlay, { isVisible: isNavigationLoading })));

package/dist/components/LanguageSwitcher.d.ts CHANGED Viewed

@@ -5,6 +5,7 @@ interface LanguageSwitcherProps {
     onLocaleChange: (locale: string) => void;
     position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
     offsetY?: number;
+    theme?: 'dark' | 'light';
     branding?: {
         required?: boolean;
         label?: string;

package/dist/components/LanguageSwitcher.js CHANGED Viewed

@@ -22,12 +22,39 @@ const LANGUAGE_FLAGS = {
     no: '🇳🇴',
     fi: '🇫🇮',
 };
-export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, position = 'bottom-right', offsetY = 20, branding, }) => {
+export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, position = 'bottom-right', offsetY = 20, theme = 'dark', branding, }) => {
     const [isOpen, setIsOpen] = useState(false);
     const containerRef = useRef(null);
     const isRight = position.endsWith('right');
     const isTop = position.startsWith('top');
     const isBottom = position.startsWith('bottom');
+    const tokens = theme === 'light'
+        ? {
+            surfaceBg: 'rgba(255, 255, 255, 0.93)',
+            surfaceHoverBg: 'rgba(245, 245, 245, 0.95)',
+            text: 'rgba(13, 13, 13, 0.96)',
+            textMuted: 'rgba(13, 13, 13, 0.74)',
+            divider: 'rgba(0, 0, 0, 0.10)',
+            insetHighlight: 'inset 0 0 1px rgba(0, 0, 0, 0.10)',
+            tabShadowRight: '-2px 0 8px rgba(0, 0, 0, 0.12), inset 0 0 1px rgba(0, 0, 0, 0.10)',
+            tabShadowLeft: '2px 0 8px rgba(0, 0, 0, 0.12), inset 0 0 1px rgba(0, 0, 0, 0.10)',
+            tabHoverShadowRight: '-4px 0 16px rgba(0, 0, 0, 0.16), inset 0 0 1px rgba(0, 0, 0, 0.12)',
+            tabHoverShadowLeft: '4px 0 16px rgba(0, 0, 0, 0.16), inset 0 0 1px rgba(0, 0, 0, 0.12)',
+            panelShadow: '0 8px 24px rgba(0, 0, 0, 0.14), inset 0 0 1px rgba(0, 0, 0, 0.10)',
+        }
+        : {
+            surfaceBg: 'rgba(26, 26, 26, 0.93)',
+            surfaceHoverBg: 'rgba(35, 35, 35, 0.95)',
+            text: 'rgba(255, 255, 255, 0.98)',
+            textMuted: 'rgba(255, 255, 255, 0.82)',
+            divider: 'rgba(255, 255, 255, 0.12)',
+            insetHighlight: 'inset 0 0 1px rgba(255, 255, 255, 0.10)',
+            tabShadowRight: '-2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.10)',
+            tabShadowLeft: '2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.10)',
+            tabHoverShadowRight: '-4px 0 16px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.15)',
+            tabHoverShadowLeft: '4px 0 16px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.15)',
+            panelShadow: '0 8px 24px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.10)',
+        };
     // Order locales: active first, then others
     const orderedLocales = [
         currentLocale,
@@ -80,17 +107,15 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
         width: '44px',
         height: '50px',
         borderRadius: isRight ? '12px 0 0 12px' : '0 12px 12px 0',
-        background: 'rgba(26, 26, 26, 0.93)',
+        background: tokens.surfaceBg,
         backdropFilter: 'blur(12px)',
-        boxShadow: isRight
-            ? '-2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.1)'
-            : '2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.1)',
+        boxShadow: isRight ? tokens.tabShadowRight : tokens.tabShadowLeft,
         cursor: 'pointer',
         fontSize: '20px',
         transition: 'all 0.2s ease',
         userSelect: 'none',
         border: 'none',
-        color: 'white',
+        color: tokens.text,
     };
     const panelStyles = {
         position: 'absolute',
@@ -102,14 +127,14 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
             : `translateY(-50%) translateX(${isRight ? '12px' : '-12px'})`,
         opacity: isOpen ? 1 : 0,
         pointerEvents: isOpen ? 'auto' : 'none',
-        background: 'rgba(26, 26, 26, 0.93)',
+        background: tokens.surfaceBg,
         backdropFilter: 'blur(12px)',
         borderRadius: '16px',
         padding: '10px 12px',
         display: 'flex',
         flexDirection: 'column',
         gap: '10px',
-        boxShadow: '0 8px 24px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.1)',
+        boxShadow: tokens.panelShadow,
         transition: 'opacity 0.25s ease, transform 0.25s ease',
     };
     const localeRowStyles = {
@@ -122,14 +147,14 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
         alignItems: 'center',
         gap: '8px',
         paddingTop: '8px',
-        borderTop: '1px solid rgba(255, 255, 255, 0.12)',
+        borderTop: `1px solid ${tokens.divider}`,
         fontSize: '12px',
-        color: 'rgba(255, 255, 255, 0.82)',
+        color: tokens.textMuted,
         userSelect: 'none',
         whiteSpace: 'nowrap',
     };
     const badgeLinkStyles = {
-        color: 'rgba(255, 255, 255, 0.92)',
+        color: tokens.text,
         textDecoration: 'none',
         display: 'inline-flex',
         alignItems: 'center',
@@ -155,15 +180,11 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
     return (React.createElement("div", { ref: containerRef, style: containerStyles, "data-Lovalingo-exclude": "true" },
         React.createElement("div", { style: rootStyles },
             React.createElement("button", { style: tabStyles, onClick: () => setIsOpen(!isOpen), onMouseEnter: (e) => {
-                    e.currentTarget.style.background = 'rgba(35, 35, 35, 0.95)';
-                    e.currentTarget.style.boxShadow = isRight
-                        ? '-4px 0 16px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.15)'
-                        : '4px 0 16px rgba(0, 0, 0, 0.3), inset 0 0 1px rgba(255, 255, 255, 0.15)';
+                    e.currentTarget.style.background = tokens.surfaceHoverBg;
+                    e.currentTarget.style.boxShadow = isRight ? tokens.tabHoverShadowRight : tokens.tabHoverShadowLeft;
                 }, onMouseLeave: (e) => {
-                    e.currentTarget.style.background = 'rgba(26, 26, 26, 0.93)';
-                    e.currentTarget.style.boxShadow = isRight
-                        ? '-2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.1)'
-                        : '2px 0 8px rgba(0, 0, 0, 0.2), inset 0 0 1px rgba(255, 255, 255, 0.1)';
+                    e.currentTarget.style.background = tokens.surfaceBg;
+                    e.currentTarget.style.boxShadow = isRight ? tokens.tabShadowRight : tokens.tabShadowLeft;
                 }, "aria-label": "Open language switcher", "aria-expanded": isOpen }, LANGUAGE_FLAGS[currentLocale] || '🌐'),
             React.createElement("div", { style: panelStyles, role: "toolbar", "aria-label": "Language options" },
                 React.createElement("div", { style: localeRowStyles }, orderedLocales.map((locale) => (React.createElement("button", { key: locale, style: flagButtonStyles(locale), onClick: (e) => {
@@ -202,5 +223,5 @@ export const LanguageSwitcher = ({ locales, currentLocale, onLocaleChange, posit
                         React.createElement("span", null,
                             branding.label || 'Localized by',
                             " ",
-                            React.createElement("strong", { style: { color: 'white' } }, "Lovalingo")))))))));
+                            React.createElement("strong", { "data-no-translate": true, style: { color: tokens.text } }, "Lovalingo")))))))));
 };

package/dist/types.d.ts CHANGED Viewed

@@ -4,9 +4,6 @@ export interface LovalingoConfig {
      * Public project key (safe to expose in the browser).
      */
     publicAnonKey?: string;
-    /**
-     * @deprecated Use `publicAnonKey`.
-     */
     apiKey?: string;
     defaultLocale: string;
     locales: string[];
@@ -15,6 +12,7 @@ export interface LovalingoConfig {
     autoPrefixLinks?: boolean;
     switcherPosition?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
     switcherOffsetY?: number;
+    switcherTheme?: 'dark' | 'light';
     editMode?: boolean;
     editKey?: string;
     pathNormalization?: PathNormalizationConfig;

package/dist/utils/api.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import { processPath } from './pathNormalizer';
+import { warnDebug, errorDebug } from './logger';
 export class LovalingoAPI {
     constructor(apiKey, apiBase, pathConfig) {
         this.entitlements = null;
@@ -11,10 +12,10 @@ export class LovalingoAPI {
     }
     warnMissingApiKey(action) {
         // Avoid hard-crashing apps; make the failure mode obvious.
-        console.warn(`[Lovalingo] Missing public project key: ${action} was skipped. Pass publicAnonKey (or apiKey) to <LovalingoProvider ...> (or set VITE_LOVALINGO_PUBLIC_ANON_KEY / VITE_LOVALINGO_API_KEY).`);
+        warnDebug(`[Lovalingo] Missing public project key: ${action} was skipped. Pass publicAnonKey to <LovalingoProvider ...> (or set VITE_LOVALINGO_PUBLIC_ANON_KEY).`);
     }
     logActivationRequired(context, response) {
-        console.error(`[Lovalingo] ${context} blocked (HTTP ${response.status}). ` +
+        errorDebug(`[Lovalingo] ${context} blocked (HTTP ${response.status}). ` +
             `This project is not activated yet. ` +
             `Publish a public manifest at "/.well-known/lovalingo.json" on your domain, ` +
             `then verify it in the Lovalingo dashboard to activate translations + SEO.`);
@@ -129,7 +130,7 @@ export class LovalingoAPI {
             }));
         }
         catch (error) {
-            console.error('Error fetching translations:', error);
+            errorDebug('Error fetching translations:', error);
             return [];
         }
     }
@@ -184,7 +185,7 @@ export class LovalingoAPI {
             return Array.isArray(data.exclusions) ? data.exclusions : [];
         }
         catch (error) {
-            console.error('Error fetching exclusions:', error);
+            errorDebug('Error fetching exclusions:', error);
             return [];
         }
     }
@@ -210,7 +211,7 @@ export class LovalingoAPI {
             return Array.isArray(data?.rules) ? data.rules : [];
         }
         catch (error) {
-            console.error('Error fetching DOM rules:', error);
+            errorDebug('Error fetching DOM rules:', error);
             return [];
         }
     }
@@ -230,7 +231,7 @@ export class LovalingoAPI {
             }
         }
         catch (error) {
-            console.error('Error saving exclusion:', error);
+            errorDebug('Error saving exclusion:', error);
             throw error;
         }
     }

package/dist/utils/logger.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare function logDebug(...args: unknown[]): void;
+export declare function warnDebug(...args: unknown[]): void;
+export declare function errorDebug(...args: unknown[]): void;

package/dist/utils/logger.js ADDED Viewed

@@ -0,0 +1,23 @@
+function isDebugEnabled() {
+    if (typeof globalThis === "undefined")
+        return false;
+    const value = globalThis.__lovalingoDebug;
+    if (value === true || value === "true" || value === 1)
+        return true;
+    return false;
+}
+export function logDebug(...args) {
+    if (!isDebugEnabled())
+        return;
+    console.log(...args);
+}
+export function warnDebug(...args) {
+    if (!isDebugEnabled())
+        return;
+    console.warn(...args);
+}
+export function errorDebug(...args) {
+    if (!isDebugEnabled())
+        return;
+    console.error(...args);
+}

package/dist/utils/markerEngine.d.ts ADDED Viewed

@@ -0,0 +1,21 @@
+type MarkerStats = {
+    totalTextNodes: number;
+    markedNodes: number;
+    skippedUnsafeNodes: number;
+    skippedExcludedNodes: number;
+    skippedNonTranslatableNodes: number;
+    totalChars: number;
+    markedChars: number;
+    skippedUnsafeChars: number;
+    skippedExcludedChars: number;
+    skippedNonTranslatableChars: number;
+    coverageRatio: number;
+    coverageRatioChars: number;
+};
+type MarkerEngineOptions = {
+    throttleMs?: number;
+};
+export declare function startMarkerEngine(options?: MarkerEngineOptions): typeof stopMarkerEngine;
+export declare function stopMarkerEngine(): void;
+export declare function getMarkerStats(): MarkerStats;
+export {};

package/dist/utils/markerEngine.js ADDED Viewed

@@ -0,0 +1,279 @@
+import { hashContent } from "./hash";
+const DEFAULT_THROTTLE_MS = 150;
+const EXCLUDE_SELECTOR = "[data-lovalingo-exclude],[data-notranslate],[translate-no],[data-no-translate]";
+const MARKER_SELECTOR = "[data-lovalingo-original]";
+const UNSAFE_CONTAINER_TAGS = new Set(["script", "style", "noscript", "template", "svg", "canvas"]);
+const DIRECT_MARK_TAGS = new Set(["option", "textarea"]);
+const ATTRIBUTE_MARKS = [
+    { attr: "title", marker: "data-lovalingo-title-original" },
+    { attr: "aria-label", marker: "data-lovalingo-aria-label-original" },
+    { attr: "placeholder", marker: "data-lovalingo-placeholder-original" },
+];
+const unsafeSelector = Array.from(UNSAFE_CONTAINER_TAGS).join(",");
+let observer = null;
+let scheduled = null;
+let running = false;
+let lastStats = buildEmptyStats();
+let throttleMs = DEFAULT_THROTTLE_MS;
+function buildEmptyStats() {
+    return {
+        totalTextNodes: 0,
+        markedNodes: 0,
+        skippedUnsafeNodes: 0,
+        skippedExcludedNodes: 0,
+        skippedNonTranslatableNodes: 0,
+        totalChars: 0,
+        markedChars: 0,
+        skippedUnsafeChars: 0,
+        skippedExcludedChars: 0,
+        skippedNonTranslatableChars: 0,
+        coverageRatio: 0,
+        coverageRatioChars: 0,
+    };
+}
+function setGlobalStats(stats) {
+    lastStats = stats;
+    if (typeof window === "undefined")
+        return;
+    window.__lovalingoMarkersReady = true;
+    window.__lovalingoMarkerStats = stats;
+}
+function isExcludedElement(el) {
+    if (!el)
+        return false;
+    return Boolean(el.closest(EXCLUDE_SELECTOR));
+}
+function findUnsafeContainer(el) {
+    if (!el)
+        return null;
+    if (!unsafeSelector)
+        return null;
+    return el.closest(unsafeSelector);
+}
+function getStableKey(el) {
+    const owner = el.closest("[data-lovalingo-key]");
+    const key = owner?.getAttribute("data-lovalingo-key") || "";
+    return key.trim();
+}
+function getElementIndex(el) {
+    const parent = el.parentElement;
+    if (!parent)
+        return 0;
+    const children = Array.from(parent.children);
+    const idx = children.indexOf(el);
+    return idx >= 0 ? idx : 0;
+}
+function getTextNodeIndex(node) {
+    let index = 0;
+    let prev = node.previousSibling;
+    while (prev) {
+        if (prev.nodeType === Node.TEXT_NODE)
+            index += 1;
+        prev = prev.previousSibling;
+    }
+    return index;
+}
+function buildElementPath(el) {
+    const parts = [];
+    let current = el;
+    while (current && current.tagName && current !== document.body) {
+        const tag = current.tagName.toLowerCase();
+        const idx = getElementIndex(current);
+        parts.push(`${tag}[${idx}]`);
+        current = current.parentElement;
+    }
+    parts.push("body");
+    return parts.reverse().join("/");
+}
+function isTranslatableText(text) {
+    if (!text || text.trim().length < 2)
+        return false;
+    if (/^(__[A-Z0-9_]+__\s*)+$/.test(text))
+        return false;
+    if (/^\d+(\.\d+)?$/.test(text))
+        return false;
+    if (!/[a-zA-Z\u00C0-\u024F\u1E00-\u1EFF]/.test(text))
+        return false;
+    return true;
+}
+function buildStableId(el, text, textIndex) {
+    const key = getStableKey(el);
+    const path = buildElementPath(el);
+    const raw = `${path}#text[${textIndex}]|${text.trim()}|${key}`;
+    return hashContent(raw);
+}
+function markElementDirect(el, rawText, stats) {
+    if (!el.hasAttribute("data-lovalingo-original")) {
+        el.setAttribute("data-lovalingo-original", rawText.trim());
+    }
+    if (!el.hasAttribute("data-lovalingo-id")) {
+        el.setAttribute("data-lovalingo-id", buildStableId(el, rawText, 0));
+    }
+    el.setAttribute("data-lovalingo-kind", "text");
+    stats.markedNodes += 1;
+    stats.markedChars += rawText.length;
+}
+function markTextNode(node, stats) {
+    const raw = node.nodeValue || "";
+    if (!raw)
+        return;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return;
+    stats.totalTextNodes += 1;
+    stats.totalChars += raw.length;
+    const parent = node.parentElement;
+    if (!parent)
+        return;
+    if (isExcludedElement(parent)) {
+        stats.skippedExcludedNodes += 1;
+        stats.skippedExcludedChars += raw.length;
+        return;
+    }
+    const unsafe = findUnsafeContainer(parent);
+    if (unsafe) {
+        stats.skippedUnsafeNodes += 1;
+        stats.skippedUnsafeChars += raw.length;
+        if (!unsafe.hasAttribute("data-lovalingo-unsafe")) {
+            unsafe.setAttribute("data-lovalingo-unsafe", unsafe.tagName.toLowerCase());
+        }
+        return;
+    }
+    if (!isTranslatableText(trimmed)) {
+        stats.skippedNonTranslatableNodes += 1;
+        stats.skippedNonTranslatableChars += raw.length;
+        return;
+    }
+    const existingMarker = parent.closest(MARKER_SELECTOR);
+    if (existingMarker) {
+        if (!existingMarker.getAttribute("data-lovalingo-id")) {
+            const textIndex = getTextNodeIndex(node);
+            existingMarker.setAttribute("data-lovalingo-id", buildStableId(parent, raw, textIndex));
+        }
+        stats.markedNodes += 1;
+        stats.markedChars += raw.length;
+        return;
+    }
+    const parentTag = parent.tagName.toLowerCase();
+    if (DIRECT_MARK_TAGS.has(parentTag)) {
+        markElementDirect(parent, raw, stats);
+        return;
+    }
+    const wrapper = document.createElement("span");
+    wrapper.setAttribute("data-lovalingo-original", trimmed);
+    wrapper.setAttribute("data-lovalingo-id", buildStableId(parent, raw, getTextNodeIndex(node)));
+    wrapper.setAttribute("data-lovalingo-kind", "text");
+    wrapper.setAttribute("data-lovalingo-marker", "1");
+    wrapper.textContent = raw;
+    try {
+        parent.replaceChild(wrapper, node);
+    }
+    catch {
+        return;
+    }
+    stats.markedNodes += 1;
+    stats.markedChars += raw.length;
+}
+function markAttributes(root) {
+    const nodes = root.querySelectorAll("[title],[aria-label],[placeholder]");
+    nodes.forEach((el) => {
+        if (isExcludedElement(el))
+            return;
+        if (findUnsafeContainer(el))
+            return;
+        for (const { attr, marker } of ATTRIBUTE_MARKS) {
+            if (el.hasAttribute(marker))
+                continue;
+            const value = el.getAttribute(attr);
+            if (!value)
+                continue;
+            const trimmed = value.trim();
+            if (!trimmed || !isTranslatableText(trimmed))
+                continue;
+            el.setAttribute(marker, trimmed);
+        }
+    });
+}
+function finalizeStats(stats) {
+    const eligibleNodes = stats.totalTextNodes -
+        stats.skippedUnsafeNodes -
+        stats.skippedExcludedNodes -
+        stats.skippedNonTranslatableNodes;
+    const eligibleChars = stats.totalChars -
+        stats.skippedUnsafeChars -
+        stats.skippedExcludedChars -
+        stats.skippedNonTranslatableChars;
+    stats.coverageRatio = eligibleNodes > 0 ? stats.markedNodes / eligibleNodes : 1;
+    stats.coverageRatioChars = eligibleChars > 0 ? stats.markedChars / eligibleChars : 1;
+}
+function scanAndMark() {
+    if (!running)
+        return;
+    const root = document.body;
+    if (!root) {
+        setGlobalStats(buildEmptyStats());
+        return;
+    }
+    const stats = buildEmptyStats();
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    let node = walker.nextNode();
+    while (node) {
+        if (node.nodeType === Node.TEXT_NODE)
+            nodes.push(node);
+        node = walker.nextNode();
+    }
+    nodes.forEach((textNode) => markTextNode(textNode, stats));
+    markAttributes(root);
+    finalizeStats(stats);
+    setGlobalStats(stats);
+}
+function scheduleScan() {
+    if (!running)
+        return;
+    if (scheduled != null)
+        return;
+    scheduled = window.setTimeout(() => {
+        scheduled = null;
+        scanAndMark();
+    }, throttleMs);
+}
+export function startMarkerEngine(options = {}) {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+        return () => undefined;
+    }
+    stopMarkerEngine();
+    running = true;
+    throttleMs = Math.max(20, options.throttleMs ?? DEFAULT_THROTTLE_MS);
+    const startObserver = () => {
+        if (!running)
+            return;
+        if (!document.body) {
+            window.setTimeout(startObserver, 50);
+            return;
+        }
+        observer = new MutationObserver(() => scheduleScan());
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true,
+            characterData: true,
+        });
+        scanAndMark();
+    };
+    startObserver();
+    return stopMarkerEngine;
+}
+export function stopMarkerEngine() {
+    running = false;
+    if (scheduled != null) {
+        window.clearTimeout(scheduled);
+        scheduled = null;
+    }
+    if (observer) {
+        observer.disconnect();
+        observer = null;
+    }
+}
+export function getMarkerStats() {
+    return lastStats;
+}

package/dist/utils/pathNormalizer.js CHANGED Viewed

@@ -8,6 +8,7 @@
  *   /dashboard/projects/4458eb10-608c-4622-a92e-ec3ed2eeb524/setup
  *   → /dashboard/projects/:id/setup
  */
+import { warnDebug } from "./logger";
 // Common patterns for dynamic segments
 const UUID_PATTERN = /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi;
 const NUMERIC_ID_PATTERN = /\/\d+(?=\/|$)/g;
@@ -40,7 +41,7 @@ export function normalizePath(path, config) {
                 }
             }
             catch (error) {
-                console.warn('[PathNormalizer] Invalid pattern:', rule.pattern, error);
+                warnDebug('[PathNormalizer] Invalid pattern:', rule.pattern, error);
             }
         }
     }

package/dist/utils/translator.js CHANGED Viewed

@@ -1,9 +1,11 @@
+import { logDebug, warnDebug, errorDebug } from './logger';
 export class Translator {
     constructor() {
         this.translationMap = new Map();
         this.exclusions = [];
         // Brand names that should NEVER be translated
         this.nonTranslatableTerms = new Set([
+            'Lovalingo',
             'Lovable', 'v0', 'Claude Code', 'Bolt', 'Base44',
             'Replit', 'GitHub', 'Supabase', 'OpenAI', 'Anthropic'
         ]);
@@ -112,7 +114,7 @@ export class Translator {
     setTranslations(translations) {
         this.translationMap.clear();
         if (!Array.isArray(translations)) {
-            console.error('[Lovalingo] setTranslations expected array, got:', typeof translations);
+            errorDebug('[Lovalingo] setTranslations expected array, got:', typeof translations);
             return;
         }
         translations.forEach(t => {
@@ -121,7 +123,7 @@ export class Translator {
                 this.translationMap.set(t.source_text.trim(), t.translated_text);
             }
         });
-        console.log(`[Lovalingo] ✅ Loaded ${this.translationMap.size} translations`);
+        logDebug(`[Lovalingo] ✅ Loaded ${this.translationMap.size} translations`);
     }
     setExclusions(exclusions) {
         this.exclusions = exclusions || [];
@@ -333,7 +335,7 @@ export class Translator {
             const hadLettersInRaw = /[a-zA-Z\u00C0-\u024F\u1E00-\u1EFF]/.test(rawHTML);
             const hadPlaceholders = Object.keys(placeholderMap).length > 0;
             if (hadLettersInRaw || hadPlaceholders) {
-                console.warn('[Lovalingo] ⚠️ Non-translatable content after extraction:', semanticElement.outerHTML.substring(0, 140));
+                warnDebug('[Lovalingo] ⚠️ Non-translatable content after extraction:', semanticElement.outerHTML.substring(0, 140));
             }
             return {
                 rawHTML,
@@ -342,7 +344,7 @@ export class Translator {
                 semanticContext
             };
         }
-        console.log(`[Lovalingo] 📝 Extracted: "${processedText.substring(0, 80)}..." with ${Object.keys(placeholderMap).length} placeholders`);
+        logDebug(`[Lovalingo] 📝 Extracted: "${processedText.substring(0, 80)}..." with ${Object.keys(placeholderMap).length} placeholders`);
         return {
             rawHTML,
             processedText,
@@ -393,7 +395,7 @@ export class Translator {
         if (SEMANTIC_BOUNDARIES.has(element.tagName)) {
             const originalHTML = element.getAttribute('data-Lovalingo-original-html');
             if (originalHTML) {
-                console.log(`[Lovalingo] 🔄 Restoring: "${element.textContent?.substring(0, 50)}..."`);
+                logDebug(`[Lovalingo] 🔄 Restoring: "${element.textContent?.substring(0, 50)}..."`);
                 // Mark current live elements before restoring
                 const markedElements = this.markElements(element);
                 // Use safe update that preserves live elements
@@ -421,11 +423,11 @@ export class Translator {
      * Restore all elements to original state
      */
     restoreDOM() {
-        console.log('[Lovalingo] 🔄 Restoring DOM to original state...');
+        logDebug('[Lovalingo] 🔄 Restoring DOM to original state...');
         const startTime = performance.now();
         this.restoreElement(document.body);
         const elapsed = performance.now() - startTime;
-        console.log(`[Lovalingo] 🏁 DOM restoration complete in ${elapsed.toFixed(2)}ms`);
+        logDebug(`[Lovalingo] 🏁 DOM restoration complete in ${elapsed.toFixed(2)}ms`);
     }
     /**
      * Mark all descendant elements with unique IDs before translation
@@ -480,7 +482,7 @@ export class Translator {
     updateElementChildren(parent, newHTML, markedElements) {
         // Safety check: Ensure parent is still in the DOM
         if (!parent.isConnected || !document.body.contains(parent)) {
-            console.warn('[Lovalingo] Parent element not in DOM, skipping translation');
+            warnDebug('[Lovalingo] Parent element not in DOM, skipping translation');
             return;
         }
         try {
@@ -497,7 +499,7 @@ export class Translator {
                 }
                 catch (e) {
                     // Node might have been removed by React already, skip
-                    console.warn('[Lovalingo] Could not remove child, likely already removed by framework');
+                    warnDebug('[Lovalingo] Could not remove child, likely already removed by framework');
                     break;
                 }
             }
@@ -507,13 +509,13 @@ export class Translator {
                     parent.appendChild(temp.firstChild);
                 }
                 catch (e) {
-                    console.warn('[Lovalingo] Could not append child:', e);
+                    warnDebug('[Lovalingo] Could not append child:', e);
                     break;
                 }
             }
         }
         catch (error) {
-            console.error('[Lovalingo] Error updating element children:', error);
+            errorDebug('[Lovalingo] Error updating element children:', error);
         }
     }
     /**
@@ -594,7 +596,7 @@ export class Translator {
                 const sourceText = originalTextAttr || content.processedText;
                 // If boundary isn't translatable, recurse to children.
                 if (!this.isTranslatableText(sourceText)) {
-                    console.log('[Lovalingo] ⏭️ Skipping non-translatable content:', sourceText.substring(0, 50));
+                    logDebug('[Lovalingo] ⏭️ Skipping non-translatable content:', sourceText.substring(0, 50));
                     Array.from(element.children).forEach((child) => {
                         if (child instanceof HTMLElement)
                             this.translateElement(child);
@@ -603,10 +605,10 @@ export class Translator {
                 }
                 const translated = this.translationMap.get(sourceText);
                 if (translated) {
-                    console.log(`[Lovalingo] ✅ Translating: "${sourceText.substring(0, 50)}..." → "${translated.substring(0, 50)}..."`);
+                    logDebug(`[Lovalingo] ✅ Translating: "${sourceText.substring(0, 50)}..." → "${translated.substring(0, 50)}..."`);
                     let reconstructedHTML = this.reconstructHTML(translated, content.placeholderMap);
                     if (/__[A-Z0-9_]+__/.test(reconstructedHTML)) {
-                        console.warn('[Lovalingo] ⚠️ Tokens remain after reconstruction, using original HTML');
+                        warnDebug('[Lovalingo] ⚠️ Tokens remain after reconstruction, using original HTML');
                         reconstructedHTML = content.rawHTML;
                     }
                     // Mark for MutationObserver suppression (prevents feedback loops on DOM updates).
@@ -624,7 +626,7 @@ export class Translator {
                     });
                 }
                 else {
-                    console.log(`[Lovalingo] ❌ Miss: "${sourceText.substring(0, 80)}..."`);
+                    logDebug(`[Lovalingo] ❌ Miss: "${sourceText.substring(0, 80)}..."`);
                 }
             }
             finally {
@@ -660,15 +662,15 @@ export class Translator {
                 // Use stored original text
                 const sourceText = originalTextAttr || content.processedText;
                 if (!this.isTranslatableText(sourceText)) {
-                    console.log('[Lovalingo] ⏭️ Skipping non-translatable content (generic):', sourceText.substring(0, 50));
+                    logDebug('[Lovalingo] ⏭️ Skipping non-translatable content (generic):', sourceText.substring(0, 50));
                     return;
                 }
                 const translated = this.translationMap.get(sourceText);
                 if (translated) {
-                    console.log(`[Lovalingo] ✅ Generic semantic: "${sourceText.substring(0, 50)}..." → "${translated.substring(0, 50)}..."`);
+                    logDebug(`[Lovalingo] ✅ Generic semantic: "${sourceText.substring(0, 50)}..." → "${translated.substring(0, 50)}..."`);
                     let reconstructedHTML = this.reconstructHTML(translated, content.placeholderMap);
                     if (/__[A-Z0-9_]+__/.test(reconstructedHTML)) {
-                        console.warn('[Lovalingo] ⚠️ Tokens remain (generic), using original HTML');
+                        warnDebug('[Lovalingo] ⚠️ Tokens remain (generic), using original HTML');
                         reconstructedHTML = content.rawHTML;
                     }
                     this.updateElementChildren(element, reconstructedHTML, markedElements);
@@ -680,7 +682,7 @@ export class Translator {
                     });
                 }
                 else {
-                    console.log(`[Lovalingo] ❌ Miss (generic): "${sourceText.substring(0, 80)}..."`);
+                    logDebug(`[Lovalingo] ❌ Miss (generic): "${sourceText.substring(0, 80)}..."`);
                 }
             }
             finally {
@@ -791,10 +793,10 @@ export class Translator {
         }
     }
     translateDOM() {
-        console.log(`[Lovalingo] 🔄 translateDOM() called with ${this.translationMap.size} translations`);
+        logDebug(`[Lovalingo] 🔄 translateDOM() called with ${this.translationMap.size} translations`);
         const startTime = performance.now();
         this.translateElement(document.body);
         const elapsed = performance.now() - startTime;
-        console.log(`[Lovalingo] 🏁 translateDOM() complete in ${elapsed.toFixed(2)}ms.`);
+        logDebug(`[Lovalingo] 🏁 translateDOM() complete in ${elapsed.toFixed(2)}ms.`);
     }
 }

package/dist/version.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare const VERSION = "0.0.26";
1	+ export declare const VERSION = "0.1.1";

package/dist/version.js CHANGED Viewed

	@@ -1 +1 @@
1	- export const VERSION = "0.0.26";
1	+ export const VERSION = "0.1.1";

package/package.json CHANGED Viewed

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