@lovalingo/lovalingo 0.5.28 → 0.6.0

package/dist/index.mjs

@@ -0,0 +1,33 @@
+import {
+  LanguageSwitcher,
+  LovalingoProvider,
+  VERSION,
+  useLovalingo,
+  useLovalingoEdit,
+  useLovalingoTranslate
+} from "./chunk-VAHA2TOX.mjs";
+import {
+  LangLink,
+  LangRouter,
+  useLang,
+  useLangNavigate
+} from "./chunk-ZVYKEEUF.mjs";
+import "./chunk-7D5LBV45.mjs";
+import {
+  createLovalingoTanStackRewrite
+} from "./chunk-CJOSN7RA.mjs";
+import "./chunk-ZMRCSUM7.mjs";
+import "./chunk-2FZR2AKF.mjs";
+export {
+  LangLink,
+  LangRouter,
+  LanguageSwitcher,
+  LovalingoProvider,
+  VERSION,
+  createLovalingoTanStackRewrite,
+  useLang,
+  useLangNavigate,
+  useLovalingo,
+  useLovalingoEdit,
+  useLovalingoTranslate
+};

package/dist/react-router.d.mts

@@ -0,0 +1,101 @@
+import React from 'react';
+import { LinkProps } from 'react-router-dom';
+
+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.
+ */
+declare function LangRouter({ children, defaultLang, langs, navigateRef, apiBase, apiKey, publicAnonKey }: LangRouterProps): React.JSX.Element;
+
+/**
+ * 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
+ */
+declare function LangLink({ to, ...props }: LinkProps): React.JSX.Element;
+
+/**
+ * useLang - Get the current language from the URL
+ *
+ * Works with LangRouter to extract language from /:lang/* routes
+ *
+ * Usage:
+ * ```tsx
+ * function MyComponent() {
+ *   const lang = useLang(); // 'en', 'fr', 'de', etc.
+ *   return <div>Current language: {lang}</div>;
+ * }
+ * ```
+ *
+ * @returns Current language code (e.g., 'en', 'fr', 'de')
+ */
+declare function useLang(): string;
+
+/**
+ * useLangNavigate - Get a language-aware navigate function
+ *
+ * Automatically prepends the current language to navigation paths
+ *
+ * Usage:
+ * ```tsx
+ * function MyComponent() {
+ *   const navigate = useLangNavigate();
+ *
+ *   const goToPricing = () => {
+ *     navigate('pricing'); // Goes to /en/pricing or /fr/pricing automatically
+ *   };
+ *
+ *   return <button onClick={goToPricing}>Pricing</button>;
+ * }
+ * ```
+ *
+ * @returns Navigate function that auto-prepends language
+ */
+declare function useLangNavigate(): (path: string, options?: {
+    replace?: boolean;
+    state?: unknown;
+}) => void;
+
+export { LangLink, LangRouter, useLang, useLangNavigate };

package/dist/react-router.d.ts

@@ -0,0 +1,101 @@
+import React from 'react';
+import { LinkProps } from 'react-router-dom';
+
+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.
+ */
+declare function LangRouter({ children, defaultLang, langs, navigateRef, apiBase, apiKey, publicAnonKey }: LangRouterProps): React.JSX.Element;
+
+/**
+ * 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
+ */
+declare function LangLink({ to, ...props }: LinkProps): React.JSX.Element;
+
+/**
+ * useLang - Get the current language from the URL
+ *
+ * Works with LangRouter to extract language from /:lang/* routes
+ *
+ * Usage:
+ * ```tsx
+ * function MyComponent() {
+ *   const lang = useLang(); // 'en', 'fr', 'de', etc.
+ *   return <div>Current language: {lang}</div>;
+ * }
+ * ```
+ *
+ * @returns Current language code (e.g., 'en', 'fr', 'de')
+ */
+declare function useLang(): string;
+
+/**
+ * useLangNavigate - Get a language-aware navigate function
+ *
+ * Automatically prepends the current language to navigation paths
+ *
+ * Usage:
+ * ```tsx
+ * function MyComponent() {
+ *   const navigate = useLangNavigate();
+ *
+ *   const goToPricing = () => {
+ *     navigate('pricing'); // Goes to /en/pricing or /fr/pricing automatically
+ *   };
+ *
+ *   return <button onClick={goToPricing}>Pricing</button>;
+ * }
+ * ```
+ *
+ * @returns Navigate function that auto-prepends language
+ */
+declare function useLangNavigate(): (path: string, options?: {
+    replace?: boolean;
+    state?: unknown;
+}) => void;
+
+export { LangLink, LangRouter, useLang, useLangNavigate };

package/dist/react-router.js

@@ -0,0 +1,353 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react-router.tsx
+var react_router_exports = {};
+__export(react_router_exports, {
+  LangLink: () => LangLink,
+  LangRouter: () => LangRouter,
+  useLang: () => useLang,
+  useLangNavigate: () => useLangNavigate
+});
+module.exports = __toCommonJS(react_router_exports);
+
+// src/components/LangRouter.tsx
+var import_react3 = __toESM(require("react"));
+var import_react_router_dom = require("react-router-dom");
+
+// src/context/LangContext.ts
+var import_react = require("react");
+var LangContext = (0, import_react.createContext)(null);
+
+// src/context/LangRoutingContext.ts
+var import_react2 = require("react");
+var LangRoutingContext = (0, import_react2.createContext)({
+  defaultLang: "",
+  nonLocalizedPaths: [],
+  inactivePages: [],
+  status: "unknown"
+});
+
+// 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 parseBootstrapNonLocalizedPaths(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const row of value) {
+    if (!row || typeof row !== "object") continue;
+    const record = row;
+    const pattern = typeof record.pattern === "string" ? record.pattern.trim() : "";
+    const match_type = typeof record.match_type === "string" ? record.match_type.trim() : "";
+    if (!pattern) continue;
+    if (match_type !== "exact" && match_type !== "prefix" && match_type !== "regex") continue;
+    out.push({ pattern, match_type });
+  }
+  return out;
+}
+function parseBootstrapInactivePages(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const row of value) {
+    if (typeof row === "string") {
+      const pagePath2 = row.trim();
+      if (pagePath2 && pagePath2.startsWith("/")) out.push(pagePath2);
+      continue;
+    }
+    if (!row || typeof row !== "object") continue;
+    const record = row;
+    const pagePath = typeof record.page_path === "string" ? record.page_path.trim() : "";
+    if (!pagePath || !pagePath.startsWith("/")) continue;
+    out.push(pagePath);
+  }
+  return out;
+}
+
+// src/utils/logger.ts
+function isDebugEnabled() {
+  if (typeof globalThis === "undefined") return false;
+  const value = globalThis.__lovalingoDebug;
+  if (value === true || value === "true" || value === 1) return true;
+  try {
+    const params = typeof window !== "undefined" ? new URLSearchParams(window.location.search) : null;
+    const query = params?.get("lovalingoDebug") || params?.get("lovalingo_debug") || "";
+    if (query === "1" || query === "true") return true;
+  } catch {
+  }
+  try {
+    const stored = typeof window !== "undefined" ? window.localStorage?.getItem("Lovalingo_debug") : null;
+    if (stored === "1" || stored === "true") return true;
+  } catch {
+  }
+  return false;
+}
+function logDebug(...args) {
+  if (!isDebugEnabled()) return;
+  console.log(...args);
+}
+
+// src/components/LangRouter.tsx
+function NavigateExporter({ navigateRef }) {
+  const navigate = (0, import_react_router_dom.useNavigate)();
+  (0, import_react3.useEffect)(() => {
+    if (navigateRef) {
+      navigateRef.current = navigate;
+    }
+  }, [navigate, navigateRef]);
+  return null;
+}
+function LangGuard({
+  lang,
+  nonLocalizedPaths,
+  defaultLang
+}) {
+  const location = (0, import_react_router_dom.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__ */ import_react3.default.createElement(import_react_router_dom.Navigate, { to: nextPath, replace: true });
+  }
+  return /* @__PURE__ */ import_react3.default.createElement(LangContext.Provider, { value: lang }, /* @__PURE__ */ import_react3.default.createElement(import_react_router_dom.Outlet, { context: { lang } }));
+}
+function RedirectToDefaultLang({
+  defaultLang,
+  children,
+  nonLocalizedPaths,
+  routingStatus
+}) {
+  const location = (0, import_react_router_dom.useLocation)();
+  const navigate = (0, import_react_router_dom.useNavigate)();
+  const shouldSkip = isNonLocalizedPath(location.pathname, nonLocalizedPaths);
+  (0, import_react3.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__ */ import_react3.default.createElement(import_react3.default.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 = (0, import_react3.useMemo)(
+    () => `Lovalingo_non_localized_paths:${resolvedApiKey || "anonymous"}`,
+    [resolvedApiKey]
+  );
+  const inactivePagesStorageKey = (0, import_react3.useMemo)(
+    () => `Lovalingo_inactive_pages:${resolvedApiKey || "anonymous"}`,
+    [resolvedApiKey]
+  );
+  const [nonLocalizedPaths, setNonLocalizedPaths] = (0, import_react3.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] = (0, import_react3.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] = (0, import_react3.useState)(() => {
+    if (!resolvedApiKey) return "unknown";
+    return nonLocalizedPaths.length > 0 || inactivePages.length > 0 ? "ready" : "loading";
+  });
+  const fetchRoutingConfig = (0, import_react3.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]);
+  (0, import_react3.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__ */ import_react3.default.createElement(import_react_router_dom.BrowserRouter, null, /* @__PURE__ */ import_react3.default.createElement(NavigateExporter, { navigateRef }), /* @__PURE__ */ import_react3.default.createElement(LangRoutingContext.Provider, { value: { defaultLang, nonLocalizedPaths, inactivePages, status: routingStatus } }, /* @__PURE__ */ import_react3.default.createElement(import_react_router_dom.Routes, null, langs.map((lang) => /* @__PURE__ */ import_react3.default.createElement(
+    import_react_router_dom.Route,
+    {
+      key: lang,
+      path: `${lang}/*`,
+      element: /* @__PURE__ */ import_react3.default.createElement(LangGuard, { lang, nonLocalizedPaths, defaultLang })
+    },
+    /* @__PURE__ */ import_react3.default.createElement(import_react_router_dom.Route, { index: true, element: /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, children) }),
+    /* @__PURE__ */ import_react3.default.createElement(import_react_router_dom.Route, { path: "*", element: /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, children) })
+  )), /* @__PURE__ */ import_react3.default.createElement(
+    import_react_router_dom.Route,
+    {
+      path: "*",
+      element: /* @__PURE__ */ import_react3.default.createElement(
+        RedirectToDefaultLang,
+        {
+          defaultLang,
+          nonLocalizedPaths,
+          routingStatus
+        },
+        children
+      )
+    }
+  ))));
+}
+
+// src/components/LangLink.tsx
+var import_react5 = __toESM(require("react"));
+var import_react_router_dom3 = require("react-router-dom");
+
+// src/hooks/useLang.ts
+var import_react_router_dom2 = require("react-router-dom");
+var import_react4 = require("react");
+function useLang() {
+  const ctxLang = (0, import_react4.useContext)(LangContext);
+  const { lang } = (0, import_react_router_dom2.useParams)();
+  return ctxLang ?? lang ?? "en";
+}
+
+// src/components/LangLink.tsx
+var import_react6 = require("react");
+function LangLink({ to, ...props }) {
+  const lang = useLang();
+  const routing = (0, import_react6.useContext)(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__ */ import_react5.default.createElement(import_react_router_dom3.Link, { ...props, to: langTo });
+}
+
+// src/hooks/useLangNavigate.ts
+var import_react_router_dom4 = require("react-router-dom");
+var import_react7 = require("react");
+function useLangNavigate() {
+  const navigate = (0, import_react_router_dom4.useNavigate)();
+  const lang = useLang();
+  const routing = (0, import_react7.useContext)(LangRoutingContext);
+  return (0, import_react7.useCallback)(
+    (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]
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LangLink,
+  LangRouter,
+  useLang,
+  useLangNavigate
+});

package/dist/react-router.mjs

@@ -0,0 +1,14 @@
+import {
+  LangLink,
+  LangRouter,
+  useLang,
+  useLangNavigate
+} from "./chunk-ZVYKEEUF.mjs";
+import "./chunk-7D5LBV45.mjs";
+import "./chunk-2FZR2AKF.mjs";
+export {
+  LangLink,
+  LangRouter,
+  useLang,
+  useLangNavigate
+};

package/dist/tanstack-router.d.mts

@@ -0,0 +1,22 @@
+type NonLocalizedPathRule = {
+    pattern: string;
+    match_type: "exact" | "prefix" | "regex";
+};
+
+type RewriteArgs = {
+    url: URL;
+};
+type LovalingoTanStackRewrite = {
+    input: (args: RewriteArgs) => URL | string | undefined;
+    output: (args: RewriteArgs) => URL | string | undefined;
+};
+type LovalingoTanStackRewriteOptions = {
+    defaultLocale: string;
+    locales: string[];
+    prefixDefaultLocale?: boolean;
+    nonLocalizedPaths?: NonLocalizedPathRule[];
+    getLocale?: () => string | undefined;
+};
+declare function createLovalingoTanStackRewrite({ defaultLocale, locales, prefixDefaultLocale, nonLocalizedPaths, getLocale, }: LovalingoTanStackRewriteOptions): LovalingoTanStackRewrite;
+
+export { type LovalingoTanStackRewrite, type LovalingoTanStackRewriteOptions, type NonLocalizedPathRule, createLovalingoTanStackRewrite };

package/dist/tanstack-router.d.ts

@@ -0,0 +1,22 @@
+type NonLocalizedPathRule = {
+    pattern: string;
+    match_type: "exact" | "prefix" | "regex";
+};
+
+type RewriteArgs = {
+    url: URL;
+};
+type LovalingoTanStackRewrite = {
+    input: (args: RewriteArgs) => URL | string | undefined;
+    output: (args: RewriteArgs) => URL | string | undefined;
+};
+type LovalingoTanStackRewriteOptions = {
+    defaultLocale: string;
+    locales: string[];
+    prefixDefaultLocale?: boolean;
+    nonLocalizedPaths?: NonLocalizedPathRule[];
+    getLocale?: () => string | undefined;
+};
+declare function createLovalingoTanStackRewrite({ defaultLocale, locales, prefixDefaultLocale, nonLocalizedPaths, getLocale, }: LovalingoTanStackRewriteOptions): LovalingoTanStackRewrite;
+
+export { type LovalingoTanStackRewrite, type LovalingoTanStackRewriteOptions, type NonLocalizedPathRule, createLovalingoTanStackRewrite };