@lovalingo/lovalingo 0.5.29 → 0.6.0

package/dist/chunk-ZMRCSUM7.mjs

@@ -0,0 +1,26 @@
+// src/components/provider/providerConstants.ts
+var LOCALE_STORAGE_KEY = "Lovalingo_locale";
+var LOADING_BG_STORAGE_PREFIX = "Lovalingo_loading_bg_color";
+var BRANDING_STORAGE_PREFIX = "Lovalingo_branding_enabled";
+var EDIT_MODE_PARAM = "edit_mode";
+var EDIT_KEY_PARAM = "edit_key";
+var LIVE_MISSES_QUERY_PARAM = "lovalingo_live_misses";
+var DEFAULT_PATH_NORMALIZATION = { enabled: true };
+var EDIT_MODE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var EDIT_UI_ATTR = "data-lovalingo-edit-ui";
+var EDIT_HIGHLIGHT_ID = "lovalingo-edit-highlight";
+var EDIT_HINT_ID = "lovalingo-edit-hint";
+
+export {
+  LOCALE_STORAGE_KEY,
+  LOADING_BG_STORAGE_PREFIX,
+  BRANDING_STORAGE_PREFIX,
+  EDIT_MODE_PARAM,
+  EDIT_KEY_PARAM,
+  LIVE_MISSES_QUERY_PARAM,
+  DEFAULT_PATH_NORMALIZATION,
+  EDIT_MODE_VALUES,
+  EDIT_UI_ATTR,
+  EDIT_HIGHLIGHT_ID,
+  EDIT_HINT_ID
+};

package/dist/chunk-ZVYKEEUF.mjs

@@ -0,0 +1,220 @@
+import {
+  LangRoutingContext,
+  logDebug
+} from "./chunk-7D5LBV45.mjs";
+import {
+  isNonLocalizedPath,
+  parseBootstrapInactivePages,
+  parseBootstrapNonLocalizedPaths
+} from "./chunk-2FZR2AKF.mjs";
+
+// src/components/LangRouter.tsx
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { BrowserRouter, Routes, Route, Navigate, Outlet, useLocation, useNavigate } from "react-router-dom";
+
+// src/context/LangContext.ts
+import { createContext } from "react";
+var LangContext = createContext(null);
+
+// src/components/LangRouter.tsx
+function NavigateExporter({ navigateRef }) {
+  const navigate = useNavigate();
+  useEffect(() => {
+    if (navigateRef) {
+      navigateRef.current = navigate;
+    }
+  }, [navigate, navigateRef]);
+  return null;
+}
+function LangGuard({
+  lang,
+  nonLocalizedPaths,
+  defaultLang
+}) {
+  const location = useLocation();
+  const prefix = `/${lang}`;
+  const restPath = location.pathname.startsWith(prefix) ? location.pathname.slice(prefix.length) || "/" : location.pathname;
+  if (isNonLocalizedPath(restPath, nonLocalizedPaths)) {
+    const nextPath = `${restPath}${location.search}${location.hash}`;
+    return /* @__PURE__ */ React.createElement(Navigate, { to: nextPath, replace: true });
+  }
+  return /* @__PURE__ */ React.createElement(LangContext.Provider, { value: lang }, /* @__PURE__ */ 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 /* @__PURE__ */ React.createElement(React.Fragment, null, children);
+}
+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 {
+        }
+      } catch (err) {
+        if (cancelled) return;
+        setRoutingStatus("error");
+        logDebug("[Lovalingo] Failed to fetch routing config:", err);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [fetchRoutingConfig, inactivePagesStorageKey, nonLocalizedStorageKey, resolvedApiKey]);
+  return /* @__PURE__ */ React.createElement(BrowserRouter, null, /* @__PURE__ */ React.createElement(NavigateExporter, { navigateRef }), /* @__PURE__ */ React.createElement(LangRoutingContext.Provider, { value: { defaultLang, nonLocalizedPaths, inactivePages, status: routingStatus } }, /* @__PURE__ */ React.createElement(Routes, null, langs.map((lang) => /* @__PURE__ */ React.createElement(
+    Route,
+    {
+      key: lang,
+      path: `${lang}/*`,
+      element: /* @__PURE__ */ React.createElement(LangGuard, { lang, nonLocalizedPaths, defaultLang })
+    },
+    /* @__PURE__ */ React.createElement(Route, { index: true, element: /* @__PURE__ */ React.createElement(React.Fragment, null, children) }),
+    /* @__PURE__ */ React.createElement(Route, { path: "*", element: /* @__PURE__ */ React.createElement(React.Fragment, null, children) })
+  )), /* @__PURE__ */ React.createElement(
+    Route,
+    {
+      path: "*",
+      element: /* @__PURE__ */ React.createElement(
+        RedirectToDefaultLang,
+        {
+          defaultLang,
+          nonLocalizedPaths,
+          routingStatus
+        },
+        children
+      )
+    }
+  ))));
+}
+
+// src/components/LangLink.tsx
+import React2 from "react";
+import { Link } from "react-router-dom";
+
+// src/hooks/useLang.ts
+import { useParams } from "react-router-dom";
+import { useContext } from "react";
+function useLang() {
+  const ctxLang = useContext(LangContext);
+  const { lang } = useParams();
+  return ctxLang ?? lang ?? "en";
+}
+
+// src/components/LangLink.tsx
+import { useContext as useContext2 } from "react";
+function LangLink({ to, ...props }) {
+  const lang = useLang();
+  const routing = useContext2(LangRoutingContext);
+  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 /* @__PURE__ */ React2.createElement(Link, { ...props, to: langTo });
+}
+
+// src/hooks/useLangNavigate.ts
+import { useNavigate as useNavigate2 } from "react-router-dom";
+import { useCallback as useCallback2, useContext as useContext3 } from "react";
+function useLangNavigate() {
+  const navigate = useNavigate2();
+  const lang = useLang();
+  const routing = useContext3(LangRoutingContext);
+  return useCallback2(
+    (path, options) => {
+      const trimmed = (path || "").toString().trim();
+      if (!trimmed) return;
+      const normalized = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+      const fullPath = isNonLocalizedPath(normalized, routing.nonLocalizedPaths) ? normalized : `/${lang}${normalized}`;
+      navigate(fullPath, options);
+    },
+    [lang, navigate, routing.nonLocalizedPaths]
+  );
+}
+
+export {
+  LangRouter,
+  useLang,
+  LangLink,
+  useLangNavigate
+};

package/dist/core.d.mts

@@ -0,0 +1,131 @@
+import React from 'react';
+
+/**
+ * Path Normalization Utility
+ *
+ * Normalizes URL paths by replacing dynamic segments (UUIDs, IDs, slugs)
+ * with placeholders to enable translation bundle sharing across similar pages.
+ *
+ * Example:
+ *   /dashboard/projects/4458eb10-608c-4622-a92e-ec3ed2eeb524/setup
+ *   → /dashboard/projects/:id/setup
+ */
+interface PathNormalizationRule {
+    pattern: string;
+    replacement: string;
+    includeSubpaths?: boolean;
+}
+interface PathNormalizationConfig {
+    enabled: boolean;
+    rules?: PathNormalizationRule[];
+    supportedLocales?: string[];
+}
+
+interface LovalingoConfig {
+    /**
+     * Public project key (safe to expose in the browser).
+     */
+    publicAnonKey?: string;
+    apiKey?: string;
+    defaultLocale: string;
+    locales: string[];
+    apiBase?: string;
+    routing?: 'query' | 'path';
+    autoPrefixLinks?: boolean;
+    overlayBgColor?: string;
+    switcherPosition?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    switcherOffsetY?: number;
+    switcherTheme?: 'dark' | 'light';
+    editMode?: boolean;
+    editKey?: string;
+    pathNormalization?: PathNormalizationConfig;
+    mode?: 'dom';
+    autoApplyRules?: boolean;
+}
+interface LovalingoContextValue {
+    locale: string;
+    setLocale: (locale: string) => void;
+    isLoading: boolean;
+    translationMap: Record<string, string>;
+    config: LovalingoConfig;
+    translateElement: (element: HTMLElement) => void;
+    translateDOM: () => void;
+    editMode: boolean;
+    toggleEditMode: () => void;
+    excludeElement: (selector: string) => Promise<void>;
+}
+interface Translation {
+    source_text: string;
+    translated_text: string;
+    source_locale: string;
+    target_locale: string;
+    content_hash?: string;
+}
+interface Exclusion {
+    selector: string;
+    type: 'css' | 'xpath';
+}
+type DomRuleType = 'replace_text' | 'set_attribute' | 'set_html' | 'add_class' | 'remove' | 'css' | 'script';
+interface DomRule {
+    id: string;
+    rule_type: DomRuleType;
+    selector?: string | null;
+    page_path?: string | null;
+    locale?: string | null;
+    payload?: {
+        matchText?: string;
+        text?: string;
+        attribute?: string;
+        value?: string;
+        html?: string;
+        className?: string;
+        css?: string;
+        script?: string;
+    };
+}
+
+interface LovalingoProviderProps extends LovalingoConfig {
+    children: React.ReactNode;
+    sitemap?: boolean;
+    seo?: boolean;
+    navigateRef?: React.MutableRefObject<((path: string) => void) | undefined>;
+}
+declare const LovalingoProvider: React.FC<LovalingoProviderProps>;
+
+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;
+    };
+}
+declare const LanguageSwitcher: React.FC<LanguageSwitcherProps>;
+
+declare const useLovalingo: () => {
+    locale: string;
+    setLocale: (locale: string) => void;
+    isLoading: boolean;
+    config: LovalingoConfig;
+};
+
+declare const useLovalingoTranslate: () => {
+    translateElement: (element: HTMLElement) => void;
+    translateDOM: () => void;
+};
+
+declare const useLovalingoEdit: () => {
+    editMode: boolean;
+    toggleEditMode: () => void;
+    excludeElement: (selector: string) => Promise<void>;
+};
+
+declare const VERSION = "0.6.0";
+
+export { type DomRule, type DomRuleType, type Exclusion, LanguageSwitcher, type LovalingoConfig, type LovalingoContextValue, LovalingoProvider, type Translation, VERSION, useLovalingo, useLovalingoEdit, useLovalingoTranslate };

package/dist/core.d.ts

@@ -0,0 +1,131 @@
+import React from 'react';
+
+/**
+ * Path Normalization Utility
+ *
+ * Normalizes URL paths by replacing dynamic segments (UUIDs, IDs, slugs)
+ * with placeholders to enable translation bundle sharing across similar pages.
+ *
+ * Example:
+ *   /dashboard/projects/4458eb10-608c-4622-a92e-ec3ed2eeb524/setup
+ *   → /dashboard/projects/:id/setup
+ */
+interface PathNormalizationRule {
+    pattern: string;
+    replacement: string;
+    includeSubpaths?: boolean;
+}
+interface PathNormalizationConfig {
+    enabled: boolean;
+    rules?: PathNormalizationRule[];
+    supportedLocales?: string[];
+}
+
+interface LovalingoConfig {
+    /**
+     * Public project key (safe to expose in the browser).
+     */
+    publicAnonKey?: string;
+    apiKey?: string;
+    defaultLocale: string;
+    locales: string[];
+    apiBase?: string;
+    routing?: 'query' | 'path';
+    autoPrefixLinks?: boolean;
+    overlayBgColor?: string;
+    switcherPosition?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    switcherOffsetY?: number;
+    switcherTheme?: 'dark' | 'light';
+    editMode?: boolean;
+    editKey?: string;
+    pathNormalization?: PathNormalizationConfig;
+    mode?: 'dom';
+    autoApplyRules?: boolean;
+}
+interface LovalingoContextValue {
+    locale: string;
+    setLocale: (locale: string) => void;
+    isLoading: boolean;
+    translationMap: Record<string, string>;
+    config: LovalingoConfig;
+    translateElement: (element: HTMLElement) => void;
+    translateDOM: () => void;
+    editMode: boolean;
+    toggleEditMode: () => void;
+    excludeElement: (selector: string) => Promise<void>;
+}
+interface Translation {
+    source_text: string;
+    translated_text: string;
+    source_locale: string;
+    target_locale: string;
+    content_hash?: string;
+}
+interface Exclusion {
+    selector: string;
+    type: 'css' | 'xpath';
+}
+type DomRuleType = 'replace_text' | 'set_attribute' | 'set_html' | 'add_class' | 'remove' | 'css' | 'script';
+interface DomRule {
+    id: string;
+    rule_type: DomRuleType;
+    selector?: string | null;
+    page_path?: string | null;
+    locale?: string | null;
+    payload?: {
+        matchText?: string;
+        text?: string;
+        attribute?: string;
+        value?: string;
+        html?: string;
+        className?: string;
+        css?: string;
+        script?: string;
+    };
+}
+
+interface LovalingoProviderProps extends LovalingoConfig {
+    children: React.ReactNode;
+    sitemap?: boolean;
+    seo?: boolean;
+    navigateRef?: React.MutableRefObject<((path: string) => void) | undefined>;
+}
+declare const LovalingoProvider: React.FC<LovalingoProviderProps>;
+
+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;
+    };
+}
+declare const LanguageSwitcher: React.FC<LanguageSwitcherProps>;
+
+declare const useLovalingo: () => {
+    locale: string;
+    setLocale: (locale: string) => void;
+    isLoading: boolean;
+    config: LovalingoConfig;
+};
+
+declare const useLovalingoTranslate: () => {
+    translateElement: (element: HTMLElement) => void;
+    translateDOM: () => void;
+};
+
+declare const useLovalingoEdit: () => {
+    editMode: boolean;
+    toggleEditMode: () => void;
+    excludeElement: (selector: string) => Promise<void>;
+};
+
+declare const VERSION = "0.6.0";
+
+export { type DomRule, type DomRuleType, type Exclusion, LanguageSwitcher, type LovalingoConfig, type LovalingoContextValue, LovalingoProvider, type Translation, VERSION, useLovalingo, useLovalingoEdit, useLovalingoTranslate };