@lovalingo/lovalingo 0.5.29 → 0.6.0

package/dist/tanstack-router.js

@@ -0,0 +1,162 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tanstack-router.ts
+var tanstack_router_exports = {};
+__export(tanstack_router_exports, {
+  createLovalingoTanStackRewrite: () => createLovalingoTanStackRewrite
+});
+module.exports = __toCommonJS(tanstack_router_exports);
+
+// src/components/provider/providerConstants.ts
+var LOCALE_STORAGE_KEY = "Lovalingo_locale";
+
+// src/utils/nonLocalizedPaths.ts
+var GLOBAL_NON_LOCALIZED_APP_PATHS = /* @__PURE__ */ new Set(["/robots.txt", "/sitemap.xml"]);
+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);
+}
+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 {
+      }
+    }
+  }
+  return false;
+}
+function isNonLocalizedPath(pathname, rules) {
+  return isGlobalNonLocalizedPath(pathname) || matchesNonLocalizedRules(pathname, rules);
+}
+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;
+}
+
+// src/tanstack-router.ts
+function normalizeLocale(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function uniq(items) {
+  return Array.from(new Set(items));
+}
+function buildPathWithLocale(locale, pathname) {
+  const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (normalizedPath === "/") return `/${locale}`;
+  return `/${locale}${normalizedPath}`;
+}
+function cloneUrlWithPathname(url, pathname) {
+  const next = new URL(url.href);
+  next.pathname = pathname || "/";
+  return next;
+}
+function readStoredLocale(supportedLocales) {
+  if (typeof window === "undefined") return "";
+  try {
+    const stored = normalizeLocale(window.localStorage?.getItem(LOCALE_STORAGE_KEY));
+    return supportedLocales.includes(stored) ? stored : "";
+  } catch {
+    return "";
+  }
+}
+function detectLocaleFromPath(pathname, supportedLocales) {
+  const first = pathname.split("/").filter(Boolean)[0] || "";
+  const normalized = normalizeLocale(first);
+  return supportedLocales.includes(normalized) ? normalized : "";
+}
+function createLovalingoTanStackRewrite({
+  defaultLocale,
+  locales,
+  prefixDefaultLocale = true,
+  nonLocalizedPaths = [],
+  getLocale
+}) {
+  const normalizedDefaultLocale = normalizeLocale(defaultLocale);
+  const supportedLocales = uniq([normalizedDefaultLocale, ...(locales || []).map(normalizeLocale)].filter(Boolean));
+  const fallbackLocale = normalizedDefaultLocale || supportedLocales[0] || "en";
+  let activeLocale = fallbackLocale;
+  const resolveOutputLocale = (pathname) => {
+    const explicitLocale = normalizeLocale(getLocale?.());
+    if (supportedLocales.includes(explicitLocale)) {
+      activeLocale = explicitLocale;
+      return explicitLocale;
+    }
+    const pathLocale = detectLocaleFromPath(pathname, supportedLocales);
+    if (pathLocale) {
+      activeLocale = pathLocale;
+      return pathLocale;
+    }
+    const storedLocale = readStoredLocale(supportedLocales);
+    if (storedLocale) {
+      activeLocale = storedLocale;
+      return storedLocale;
+    }
+    return supportedLocales.includes(activeLocale) ? activeLocale : fallbackLocale;
+  };
+  return {
+    input: ({ url }) => {
+      const pathLocale = detectLocaleFromPath(url.pathname, supportedLocales);
+      if (!pathLocale) return void 0;
+      activeLocale = pathLocale;
+      const stripped = stripLocalePrefix(url.pathname, supportedLocales);
+      return cloneUrlWithPathname(url, stripped || "/");
+    },
+    output: ({ url }) => {
+      const internalPath = stripLocalePrefix(url.pathname, supportedLocales);
+      if (isNonLocalizedPath(internalPath, nonLocalizedPaths)) return void 0;
+      if (detectLocaleFromPath(url.pathname, supportedLocales)) return void 0;
+      const locale = resolveOutputLocale(url.pathname);
+      if (!prefixDefaultLocale && locale === fallbackLocale) return void 0;
+      return cloneUrlWithPathname(url, buildPathWithLocale(locale, internalPath));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLovalingoTanStackRewrite
+});

package/dist/tanstack-router.mjs

@@ -0,0 +1,8 @@
+import {
+  createLovalingoTanStackRewrite
+} from "./chunk-CJOSN7RA.mjs";
+import "./chunk-ZMRCSUM7.mjs";
+import "./chunk-2FZR2AKF.mjs";
+export {
+  createLovalingoTanStackRewrite
+};

package/package.json

@@ -1,9 +1,33 @@
 {
   "name": "@lovalingo/lovalingo",
-  "version": "0.5.29",
+  "version": "0.6.0",
   "description": "React translation runtime with i18n routing, deterministic bundles + DOM rules, and zero-flash rendering.",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.mjs",
+      "require": "./dist/core.js"
+    },
+    "./react-router": {
+      "types": "./dist/react-router.d.ts",
+      "import": "./dist/react-router.mjs",
+      "require": "./dist/react-router.js"
+    },
+    "./tanstack-router": {
+      "types": "./dist/tanstack-router.d.ts",
+      "import": "./dist/tanstack-router.mjs",
+      "require": "./dist/tanstack-router.js"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -11,7 +35,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "build": "tsup src/index.tsx src/core.tsx src/react-router.tsx src/tanstack-router.ts --format esm,cjs --dts --external react,react-dom,react-router-dom --clean",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -36,10 +60,17 @@
     "react-dom": "^18.0.0",
     "react-router-dom": "^6.30.3"
   },
+  "peerDependenciesMeta": {
+    "react-router-dom": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/node": "^24.9.1",
     "@types/react": "^18.3.1",
     "@types/react-dom": "^18.3.0",
+    "react-router-dom": "^6.30.4",
+    "tsup": "^8.5.1",
     "typescript": "^5.0.0"
   },
   "repository": {

package/dist/__tests__/languageFlags.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/languageFlags.test.js

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { countryCodeToFlagEmoji, normalizeLocaleCode, parseLocale, resolveLocaleFlag } from "../utils/languageFlags";
-describe("languageFlags", () => {
-    it("normalizes locale codes with case and underscore variants", () => {
-        expect(normalizeLocaleCode("TR")).toBe("tr");
-        expect(normalizeLocaleCode("tr_TR")).toBe("tr-tr");
-        expect(normalizeLocaleCode("tr-TR")).toBe("tr-tr");
-    });
-    it("parses language and region", () => {
-        expect(parseLocale("en-CA")).toEqual({ language: "en", region: "CA" });
-        expect(parseLocale("fr")).toEqual({ language: "fr", region: null });
-    });
-    it("returns consistent flag for TR variants", () => {
-        expect(resolveLocaleFlag("TR")).toBe("🇹🇷");
-        expect(resolveLocaleFlag("tr")).toBe("🇹🇷");
-        expect(resolveLocaleFlag("tr-TR")).toBe("🇹🇷");
-        expect(resolveLocaleFlag("tr_TR")).toBe("🇹🇷");
-    });
-    it("uses region flag when locale includes region", () => {
-        expect(resolveLocaleFlag("en-CA")).toBe("🇨🇦");
-        expect(resolveLocaleFlag("pt-BR")).toBe("🇧🇷");
-    });
-    it("uses language default region when locale has no region", () => {
-        expect(resolveLocaleFlag("en")).toBe("🇬🇧");
-        expect(resolveLocaleFlag("zh")).toBe("🇨🇳");
-        expect(resolveLocaleFlag("pt")).toBe("🇵🇹");
-    });
-    it("falls back to globe for unknown or invalid locale", () => {
-        expect(resolveLocaleFlag("zzz")).toBe("🌐");
-        expect(resolveLocaleFlag("")).toBe("🌐");
-        expect(resolveLocaleFlag(null)).toBe("🌐");
-    });
-    it("never falls back to white flag", () => {
-        expect(resolveLocaleFlag("zzz")).not.toBe("🏳️");
-        expect(resolveLocaleFlag("foo-bar-baz")).not.toBe("🏳️");
-    });
-    it("converts country code to emoji", () => {
-        expect(countryCodeToFlagEmoji("ca")).toBe("🇨🇦");
-        expect(countryCodeToFlagEmoji("PT")).toBe("🇵🇹");
-        expect(countryCodeToFlagEmoji("ZZZ")).toBeNull();
-    });
-});

package/dist/__tests__/mergeEntitlements.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/mergeEntitlements.test.js

@@ -1,27 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mergeEntitlementsSeoEnabled } from "../utils/mergeEntitlements";
-describe("mergeEntitlementsSeoEnabled", () => {
-    it("merges seoEnabled when provided", () => {
-        const entitlements = {
-            tier: "starter",
-            maxTargetLocales: 1,
-            allowedTargetLocales: [],
-            brandingRequired: true,
-            hreflangEnabled: false,
-        };
-        const merged = mergeEntitlementsSeoEnabled(entitlements, false);
-        expect(merged?.seoEnabled).toBe(false);
-    });
-    it("returns the same object when seoEnabled is not a boolean", () => {
-        const entitlements = {
-            tier: "startup",
-            maxTargetLocales: 3,
-            allowedTargetLocales: ["zh"],
-            brandingRequired: false,
-            hreflangEnabled: true,
-            seoEnabled: true,
-        };
-        const merged = mergeEntitlementsSeoEnabled(entitlements, null);
-        expect(merged).toBe(entitlements);
-    });
-});

package/dist/components/AixsterProvider.d.ts

@@ -1 +0,0 @@
-export { LovalingoProvider } from "./LovalingoProvider";

package/dist/components/AixsterProvider.js

@@ -1 +0,0 @@
-export { LovalingoProvider } from "./LovalingoProvider";

package/dist/components/LangLink.d.ts

@@ -1,20 +0,0 @@
-import React from 'react';
-import { LinkProps } from 'react-router-dom';
-/**
- * LangLink - Language-aware Link component
- *
- * Automatically prepends the current language to all navigation paths
- *
- * Usage:
- * ```tsx
- * // Instead of:
- * <Link to={`/${locale}/pricing`}>Pricing</Link>
- *
- * // Just write:
- * <LangLink to="pricing">Pricing</LangLink>
- * // Automatically becomes /en/pricing or /fr/pricing
- * ```
- *
- * All props from React Router's <Link> are supported
- */
-export declare function LangLink({ to, ...props }: LinkProps): React.JSX.Element;

package/dist/components/LangLink.js

@@ -1,38 +0,0 @@
-import React from 'react';
-import { Link } from 'react-router-dom';
-import { useLang } from '../hooks/useLang';
-import { useContext } from 'react';
-import { LangRoutingContext } from '../context/LangRoutingContext';
-import { isNonLocalizedPath } from '../utils/nonLocalizedPaths';
-/**
- * LangLink - Language-aware Link component
- *
- * Automatically prepends the current language to all navigation paths
- *
- * Usage:
- * ```tsx
- * // Instead of:
- * <Link to={`/${locale}/pricing`}>Pricing</Link>
- *
- * // Just write:
- * <LangLink to="pricing">Pricing</LangLink>
- * // Automatically becomes /en/pricing or /fr/pricing
- * ```
- *
- * All props from React Router's <Link> are supported
- */
-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 || '').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

@@ -1,37 +0,0 @@
-import React from 'react';
-interface LangRouterProps {
-    children: React.ReactNode;
-    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
- *
- * Usage:
- * ```tsx
- * const navigateRef = useRef();
- *
- * <LangRouter defaultLang="en" langs={['en', 'fr', 'de', 'ko']} navigateRef={navigateRef}>
- *   <Routes>
- *     <Route path="/" element={<Home />} />
- *     <Route path="home" element={<Home />} />
- *     <Route path="pricing" element={<Pricing />} />
- *   </Routes>
- * </LangRouter>
- * ```
- *
- * This automatically creates routes:
- * - /en (root)
- * - /en/home
- * - /en/pricing
- * - /fr (root)
- * - /fr/home
- * - /fr/pricing
- * - etc.
- */
-export declare function LangRouter({ children, defaultLang, langs, navigateRef, apiBase, apiKey, publicAnonKey }: LangRouterProps): React.JSX.Element;
-export {};

package/dist/components/LangRouter.js

@@ -1,191 +0,0 @@
-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';
-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
- */
-function NavigateExporter({ navigateRef }) {
-    const navigate = useNavigate();
-    useEffect(() => {
-        if (navigateRef) {
-            navigateRef.current = navigate;
-        }
-    }, [navigate, navigateRef]);
-    return null;
-}
-/**
- * LangGuard - Internal component that validates language and provides it to children
- */
-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;
-    // 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 });
-    }
-    // Valid language - render children (user's routes)
-    return (React.createElement(LangContext.Provider, { value: lang },
-        React.createElement(Outlet, { context: { lang } })));
-}
-function RedirectToDefaultLang({ defaultLang, children, nonLocalizedPaths, routingStatus, }) {
-    const location = useLocation();
-    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
- *
- * Usage:
- * ```tsx
- * const navigateRef = useRef();
- *
- * <LangRouter defaultLang="en" langs={['en', 'fr', 'de', 'ko']} navigateRef={navigateRef}>
- *   <Routes>
- *     <Route path="/" element={<Home />} />
- *     <Route path="home" element={<Home />} />
- *     <Route path="pricing" element={<Pricing />} />
- *   </Routes>
- * </LangRouter>
- * ```
- *
- * This automatically creates routes:
- * - /en (root)
- * - /en/home
- * - /en/pricing
- * - /fr (root)
- * - /fr/home
- * - /fr/pricing
- * - etc.
- */
-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(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.d.ts

@@ -1,17 +0,0 @@
-import React from 'react';
-interface LanguageSwitcherProps {
-    locales: string[];
-    currentLocale: string;
-    onLocaleChange: (locale: string) => void;
-    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
-    offsetY?: number;
-    theme?: 'dark' | 'light';
-    branding?: {
-        required?: boolean;
-        enabled?: boolean;
-        label?: string;
-        href?: string;
-    };
-}
-export declare const LanguageSwitcher: React.FC<LanguageSwitcherProps>;
-export {};