@lovalingo/lovalingo 0.5.29 → 0.6.0

package/README.md

@@ -52,6 +52,40 @@ export function App() {
 
 URLs look like: `/de/pricing`.
 
+## TanStack Start / TanStack Router
+
+Use the router-free core entry and TanStack rewrite helper. Do not add React Router to TanStack apps.
+
+```tsx
+// src/router.tsx
+import { createLovalingoTanStackRewrite } from "@lovalingo/lovalingo/tanstack-router";
+
+const lovalingoLocales = ["en", "de", "fr"] as const;
+
+const router = createRouter({
+  routeTree,
+  rewrite: createLovalingoTanStackRewrite({
+    defaultLocale: "en",
+    locales: [...lovalingoLocales],
+    prefixDefaultLocale: true,
+  }),
+});
+```
+
+```tsx
+// src/routes/__root.tsx
+import { Outlet } from "@tanstack/react-router";
+import { LovalingoProvider } from "@lovalingo/lovalingo/core";
+
+function RootComponent() {
+  return (
+    <LovalingoProvider publicAnonKey="aix_your_public_anon_key" defaultLocale="en" locales={["de", "fr"]} routing="path" autoPrefixLinks={false}>
+      <Outlet />
+    </LovalingoProvider>
+  );
+}
+```
+
 ## Next.js (App Router)
 
 ```tsx

package/dist/chunk-2FZR2AKF.mjs

@@ -0,0 +1,88 @@
+// 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;
+}
+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;
+}
+
+export {
+  isNonLocalizedPath,
+  stripLocalePrefix,
+  parseBootstrapNonLocalizedPaths,
+  parseBootstrapInactivePages
+};

package/dist/chunk-7D5LBV45.mjs

@@ -0,0 +1,46 @@
+// src/context/LangRoutingContext.ts
+import { createContext } from "react";
+var LangRoutingContext = createContext({
+  defaultLang: "",
+  nonLocalizedPaths: [],
+  inactivePages: [],
+  status: "unknown"
+});
+
+// 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);
+}
+function warnDebug(...args) {
+  if (!isDebugEnabled()) return;
+  console.warn(...args);
+}
+function errorDebug(...args) {
+  if (!isDebugEnabled()) return;
+  console.error(...args);
+}
+
+export {
+  LangRoutingContext,
+  logDebug,
+  warnDebug,
+  errorDebug
+};

package/dist/chunk-CJOSN7RA.mjs

@@ -0,0 +1,90 @@
+import {
+  LOCALE_STORAGE_KEY
+} from "./chunk-ZMRCSUM7.mjs";
+import {
+  isNonLocalizedPath,
+  stripLocalePrefix
+} from "./chunk-2FZR2AKF.mjs";
+
+// 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));
+    }
+  };
+}
+
+export {
+  createLovalingoTanStackRewrite
+};