@better-translate/tanstack-router 1.0.0

package/dist/navigation.cjs

@@ -0,0 +1,400 @@
+"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/navigation.tsx
+var navigation_exports = {};
+__export(navigation_exports, {
+  createNavigationFunctions: () => createNavigationFunctions
+});
+module.exports = __toCommonJS(navigation_exports);
+var import_react = require("react");
+
+// src/shared.ts
+var DEFAULT_ROUTE_TEMPLATE = "/{-$locale}";
+function hasLocale(locales, value) {
+  return locales.includes(value);
+}
+function normalizePathname(pathname) {
+  if (!pathname) {
+    return "/";
+  }
+  return pathname.startsWith("/") ? pathname : `/${pathname}`;
+}
+function isPathnameInScope(pathname, routing) {
+  return analyzePathname(pathname, routing).inScope;
+}
+function stripLocaleFromPathname(pathname, routing) {
+  const analyzed = analyzePathname(pathname, routing);
+  return analyzed.inScope ? analyzed.deLocalizedPathname : normalizePathname(pathname);
+}
+function localizePathname(pathname, locale, routing) {
+  const normalizedPathname = normalizePathname(pathname);
+  const deLocalizedPathname = stripLocaleFromPathname(
+    normalizedPathname,
+    routing
+  );
+  if (!isPathnameInScope(deLocalizedPathname, routing)) {
+    return normalizedPathname;
+  }
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  if (!parsedTemplate.isRequired && locale === routing.defaultLocale) {
+    return deLocalizedPathname;
+  }
+  const pathnameSegments = splitPathname(deLocalizedPathname);
+  const localizedSegments = [...pathnameSegments];
+  localizedSegments.splice(parsedTemplate.localeSegmentIndex, 0, locale);
+  return joinPathname(localizedSegments);
+}
+function splitHrefString(href) {
+  const hashIndex = href.indexOf("#");
+  const searchIndex = href.indexOf("?");
+  const pathnameEnd = hashIndex === -1 ? searchIndex === -1 ? href.length : searchIndex : searchIndex === -1 ? hashIndex : Math.min(searchIndex, hashIndex);
+  const pathname = href.slice(0, pathnameEnd) || "/";
+  const search = searchIndex === -1 ? "" : href.slice(searchIndex, hashIndex === -1 ? href.length : hashIndex);
+  const hash = hashIndex === -1 ? "" : href.slice(hashIndex);
+  return {
+    hash,
+    pathname: normalizePathname(pathname),
+    search
+  };
+}
+function isAbsoluteHref(href) {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(href) || href.startsWith("//");
+}
+function parseRouteTemplate(routeTemplate) {
+  const normalizedRouteTemplate = normalizePathname(
+    routeTemplate ?? DEFAULT_ROUTE_TEMPLATE
+  );
+  const localizedSegments = splitPathname(normalizedRouteTemplate);
+  let localeSegmentIndex = -1;
+  let localeParamName = "";
+  let isRequired = false;
+  for (let index = 0; index < localizedSegments.length; index += 1) {
+    const segment = localizedSegments[index];
+    const localeMatch = /^\{(-?)\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}$/.exec(segment);
+    if (localeMatch) {
+      if (localeSegmentIndex !== -1) {
+        throw new Error(
+          `Route template "${normalizedRouteTemplate}" must contain exactly one locale segment.`
+        );
+      }
+      localeSegmentIndex = index;
+      localeParamName = localeMatch[2];
+      isRequired = localeMatch[1] !== "-";
+      continue;
+    }
+    if (looksDynamic(segment)) {
+      throw new Error(
+        `Route template "${normalizedRouteTemplate}" can only contain one locale segment like "{-$locale}" or "{$locale}" plus static path segments.`
+      );
+    }
+  }
+  if (localeSegmentIndex === -1) {
+    throw new Error(
+      `Route template "${normalizedRouteTemplate}" must contain one locale segment like "{-$locale}" or "{$locale}".`
+    );
+  }
+  const deLocalizedSegments = localizedSegments.filter(
+    (_, index) => index !== localeSegmentIndex
+  );
+  return {
+    deLocalizedSegments,
+    isRequired,
+    localeParamName,
+    localeSegment: localizedSegments[localeSegmentIndex],
+    localeSegmentIndex,
+    localizedSegments,
+    routeTemplate: normalizedRouteTemplate
+  };
+}
+function analyzePathname(pathname, routing) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(pathname);
+  let explicitLocale;
+  let localePathIndex = -1;
+  let pathnameIndex = 0;
+  for (let templateIndex = 0; templateIndex < parsedTemplate.localizedSegments.length; templateIndex += 1) {
+    if (templateIndex === parsedTemplate.localeSegmentIndex) {
+      const maybeLocale = pathnameSegments[pathnameIndex];
+      if (maybeLocale && hasLocale(routing.locales, maybeLocale)) {
+        explicitLocale = maybeLocale;
+        localePathIndex = pathnameIndex;
+        pathnameIndex += 1;
+      }
+      continue;
+    }
+    const templateSegment = parsedTemplate.localizedSegments[templateIndex];
+    const pathnameSegment = pathnameSegments[pathnameIndex];
+    if (pathnameSegment !== templateSegment) {
+      return {
+        deLocalizedPathname: normalizePathname(pathname),
+        explicitLocale: void 0,
+        inScope: false
+      };
+    }
+    pathnameIndex += 1;
+  }
+  if (localePathIndex === -1) {
+    return {
+      deLocalizedPathname: joinPathname(pathnameSegments),
+      explicitLocale: void 0,
+      inScope: true
+    };
+  }
+  const deLocalizedSegments = [...pathnameSegments];
+  deLocalizedSegments.splice(localePathIndex, 1);
+  return {
+    deLocalizedPathname: joinPathname(deLocalizedSegments),
+    explicitLocale,
+    inScope: true
+  };
+}
+function looksDynamic(segment) {
+  return segment.startsWith("[") || segment.startsWith("$") || segment.includes("{") || segment.includes("}");
+}
+function splitPathname(pathname) {
+  return normalizePathname(pathname).split("/").filter(Boolean);
+}
+function joinPathname(segments) {
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+
+// src/navigation.tsx
+function createNavigationFunctions({
+  Link: LinkComponent,
+  routing,
+  useLocation: useInjectedLocation,
+  useNavigate: useInjectedNavigate,
+  useParams: useInjectedParams,
+  useRouter: useInjectedRouter
+}) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  function getPathname({
+    href,
+    locale = routing.defaultLocale
+  }) {
+    return localizePathname(href, locale, routing);
+  }
+  const Link = ((rawProps) => {
+    const localizedOptions = getLocalizedOptions(
+      rawProps,
+      useInjectedLocation().pathname,
+      resolveActiveLocale(
+        useInjectedParams(),
+        routing,
+        parsedTemplate.localeParamName
+      ),
+      routing,
+      parsedTemplate.localeParamName,
+      parsedTemplate.localeSegment,
+      parsedTemplate.isRequired
+    );
+    return (0, import_react.createElement)(
+      LinkComponent,
+      localizedOptions
+    );
+  });
+  function usePathname() {
+    return stripLocaleFromPathname(useInjectedLocation().pathname, routing);
+  }
+  function useLocale() {
+    return resolveActiveLocale(
+      useInjectedParams(),
+      routing,
+      parsedTemplate.localeParamName
+    );
+  }
+  function useNavigate() {
+    const navigate = useInjectedNavigate();
+    const pathname = useInjectedLocation().pathname;
+    const activeLocale = useLocale();
+    return ((options) => navigate(
+      getLocalizedOptions(
+        options,
+        pathname,
+        activeLocale,
+        routing,
+        parsedTemplate.localeParamName,
+        parsedTemplate.localeSegment,
+        parsedTemplate.isRequired
+      )
+    ));
+  }
+  function useRouter() {
+    const router = useInjectedRouter();
+    const pathname = useInjectedLocation().pathname;
+    const activeLocale = useLocale();
+    return {
+      ...router,
+      buildLocation(options) {
+        return router.buildLocation(
+          getLocalizedOptions(
+            options,
+            pathname,
+            activeLocale,
+            routing,
+            parsedTemplate.localeParamName,
+            parsedTemplate.localeSegment,
+            parsedTemplate.isRequired
+          )
+        );
+      },
+      navigate(options) {
+        return router.navigate(
+          getLocalizedOptions(
+            options,
+            pathname,
+            activeLocale,
+            routing,
+            parsedTemplate.localeParamName,
+            parsedTemplate.localeSegment,
+            parsedTemplate.isRequired
+          )
+        );
+      },
+      preloadRoute(options) {
+        return router.preloadRoute?.(
+          getLocalizedOptions(
+            options,
+            pathname,
+            activeLocale,
+            routing,
+            parsedTemplate.localeParamName,
+            parsedTemplate.localeSegment,
+            parsedTemplate.isRequired
+          )
+        );
+      }
+    };
+  }
+  return {
+    Link,
+    getPathname,
+    useLocale,
+    useNavigate,
+    usePathname,
+    useRouter
+  };
+}
+function getLocalizedOptions(options, currentPathname, activeLocale, routing, localeParamName, localeSegment, isRequired) {
+  const nextLocale = options.locale ?? activeLocale;
+  const localized = {
+    ...options
+  };
+  delete localized.locale;
+  if (!shouldLocalizeTarget(
+    options.to,
+    currentPathname,
+    routing,
+    localeParamName,
+    localeSegment
+  )) {
+    return localized;
+  }
+  if (typeof options.to === "string" && shouldRewriteTo(options.to) && !pathContainsLocaleParam(options.to, localeParamName)) {
+    localized.to = localizePathname(
+      options.to,
+      nextLocale,
+      routing
+    );
+  }
+  localized.params = localizeParams(
+    options.params,
+    localeParamName,
+    isRequired ? nextLocale : nextLocale === routing.defaultLocale ? void 0 : nextLocale
+  );
+  return localized;
+}
+function localizeParams(params, localeParamName, locale) {
+  if (params === true || params === void 0) {
+    return (current) => mergeLocaleParam(current, localeParamName, locale);
+  }
+  if (typeof params === "function") {
+    return (current) => mergeLocaleParam(
+      params(
+        current
+      ),
+      localeParamName,
+      locale
+    );
+  }
+  if (params && typeof params === "object") {
+    return mergeLocaleParam(
+      params,
+      localeParamName,
+      locale
+    );
+  }
+  return params;
+}
+function mergeLocaleParam(params, localeParamName, locale) {
+  const nextParams = {
+    ...params ?? {}
+  };
+  if (locale === void 0) {
+    delete nextParams[localeParamName];
+    return nextParams;
+  }
+  nextParams[localeParamName] = locale;
+  return nextParams;
+}
+function shouldLocalizeTarget(to, currentPathname, routing, localeParamName, localeSegment) {
+  if (typeof to !== "string" || to === "" || to === "." || to.startsWith(".")) {
+    return isPathnameInScope(currentPathname, routing);
+  }
+  if (to.startsWith("#") || to.startsWith("?")) {
+    return isPathnameInScope(currentPathname, routing);
+  }
+  if (isAbsoluteHref(to)) {
+    return false;
+  }
+  const { pathname } = splitHrefString(to);
+  const normalizedPathname = stripLocalePlaceholder(
+    pathname,
+    localeParamName,
+    localeSegment
+  );
+  return isPathnameInScope(normalizedPathname, routing);
+}
+function pathContainsLocaleParam(to, localeParamName) {
+  return to.split("/").some((s) => s === `$${localeParamName}` || s === `{$${localeParamName}}`);
+}
+function shouldRewriteTo(to) {
+  return !to.startsWith(".") && !to.startsWith("#") && !to.startsWith("?") && !isAbsoluteHref(to);
+}
+function stripLocalePlaceholder(pathname, localeParamName, localeSegment) {
+  const localeTokens = /* @__PURE__ */ new Set([
+    localeSegment,
+    `$${localeParamName}`,
+    `{$${localeParamName}}`
+  ]);
+  const segments = pathname.split("/").filter(Boolean).filter((segment) => !localeTokens.has(segment));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function resolveActiveLocale(params, routing, localeParamName) {
+  const localeParam = params[localeParamName];
+  if (typeof localeParam === "string" && routing.locales.includes(localeParam)) {
+    return localeParam;
+  }
+  return routing.defaultLocale;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNavigationFunctions
+});

package/dist/navigation.d.cts

@@ -0,0 +1,46 @@
+import { ReactElement } from 'react';
+import { BuildLocationFn, AnyRouter, RegisteredRouter, NavigateOptions, LinkComponent, UseNavigateResult, LinkComponentProps } from '@tanstack/react-router';
+import { RoutingConfig } from './index.cjs';
+
+type ParamsLike = Record<string, string | undefined>;
+type LocalizedLinkComponent<TLocale extends string, TDefaultFrom extends string> = <TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = TDefaultFrom, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: LinkComponentProps<"a", TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    locale?: TLocale;
+}) => ReactElement;
+interface GetPathnameOptions<TLocale extends string> {
+    href: string;
+    locale?: TLocale;
+}
+type LocalizedUseNavigateResult<TLocale extends string, TDefaultFrom extends string> = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends string = TDefaultFrom, TMaskFrom extends string = TFrom, TMaskTo extends string = "">(options: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    locale?: TLocale;
+}) => Promise<void>;
+type LocalizedBuildLocationFn<TLocale extends string> = (options: Record<string, unknown> & {
+    locale?: TLocale;
+}) => ReturnType<BuildLocationFn>;
+type LocalizedPreloadRouteFn<TLocale extends string> = (options: Record<string, unknown> & {
+    locale?: TLocale;
+}) => Promise<unknown>;
+type LocalizedRouter<TLocale extends string, TRouter extends AnyRouter> = Omit<TRouter, "buildLocation" | "navigate" | "preloadRoute"> & {
+    buildLocation: LocalizedBuildLocationFn<TLocale>;
+    navigate: LocalizedUseNavigateResult<TLocale, string>;
+    preloadRoute?: LocalizedPreloadRouteFn<TLocale>;
+};
+interface NavigationFunctionsConfig<TLocale extends string, TDefaultFrom extends string, TRouter extends AnyRouter, TParams extends ParamsLike> {
+    Link: LinkComponent<"a", TDefaultFrom>;
+    routing: RoutingConfig<TLocale>;
+    useLocation: () => {
+        pathname: string;
+    };
+    useNavigate: () => UseNavigateResult<TDefaultFrom>;
+    useParams: () => TParams;
+    useRouter: () => TRouter;
+}
+declare function createNavigationFunctions<TLocale extends string, TDefaultFrom extends string = string, TRouter extends AnyRouter = AnyRouter, TParams extends ParamsLike = ParamsLike>({ Link: LinkComponent, routing, useLocation: useInjectedLocation, useNavigate: useInjectedNavigate, useParams: useInjectedParams, useRouter: useInjectedRouter, }: NavigationFunctionsConfig<TLocale, TDefaultFrom, TRouter, TParams>): {
+    Link: LocalizedLinkComponent<TLocale, TDefaultFrom>;
+    getPathname: ({ href, locale, }: GetPathnameOptions<TLocale>) => string;
+    useLocale: () => TLocale;
+    useNavigate: () => LocalizedUseNavigateResult<TLocale, TDefaultFrom>;
+    usePathname: () => string;
+    useRouter: () => LocalizedRouter<TLocale, TRouter>;
+};
+
+export { type GetPathnameOptions, type LocalizedBuildLocationFn, type LocalizedPreloadRouteFn, type LocalizedRouter, type LocalizedUseNavigateResult, type NavigationFunctionsConfig, createNavigationFunctions };

package/dist/navigation.d.ts

@@ -0,0 +1,46 @@
+import { ReactElement } from 'react';
+import { BuildLocationFn, AnyRouter, RegisteredRouter, NavigateOptions, LinkComponent, UseNavigateResult, LinkComponentProps } from '@tanstack/react-router';
+import { RoutingConfig } from './index.js';
+
+type ParamsLike = Record<string, string | undefined>;
+type LocalizedLinkComponent<TLocale extends string, TDefaultFrom extends string> = <TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = TDefaultFrom, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: LinkComponentProps<"a", TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    locale?: TLocale;
+}) => ReactElement;
+interface GetPathnameOptions<TLocale extends string> {
+    href: string;
+    locale?: TLocale;
+}
+type LocalizedUseNavigateResult<TLocale extends string, TDefaultFrom extends string> = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends string = TDefaultFrom, TMaskFrom extends string = TFrom, TMaskTo extends string = "">(options: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    locale?: TLocale;
+}) => Promise<void>;
+type LocalizedBuildLocationFn<TLocale extends string> = (options: Record<string, unknown> & {
+    locale?: TLocale;
+}) => ReturnType<BuildLocationFn>;
+type LocalizedPreloadRouteFn<TLocale extends string> = (options: Record<string, unknown> & {
+    locale?: TLocale;
+}) => Promise<unknown>;
+type LocalizedRouter<TLocale extends string, TRouter extends AnyRouter> = Omit<TRouter, "buildLocation" | "navigate" | "preloadRoute"> & {
+    buildLocation: LocalizedBuildLocationFn<TLocale>;
+    navigate: LocalizedUseNavigateResult<TLocale, string>;
+    preloadRoute?: LocalizedPreloadRouteFn<TLocale>;
+};
+interface NavigationFunctionsConfig<TLocale extends string, TDefaultFrom extends string, TRouter extends AnyRouter, TParams extends ParamsLike> {
+    Link: LinkComponent<"a", TDefaultFrom>;
+    routing: RoutingConfig<TLocale>;
+    useLocation: () => {
+        pathname: string;
+    };
+    useNavigate: () => UseNavigateResult<TDefaultFrom>;
+    useParams: () => TParams;
+    useRouter: () => TRouter;
+}
+declare function createNavigationFunctions<TLocale extends string, TDefaultFrom extends string = string, TRouter extends AnyRouter = AnyRouter, TParams extends ParamsLike = ParamsLike>({ Link: LinkComponent, routing, useLocation: useInjectedLocation, useNavigate: useInjectedNavigate, useParams: useInjectedParams, useRouter: useInjectedRouter, }: NavigationFunctionsConfig<TLocale, TDefaultFrom, TRouter, TParams>): {
+    Link: LocalizedLinkComponent<TLocale, TDefaultFrom>;
+    getPathname: ({ href, locale, }: GetPathnameOptions<TLocale>) => string;
+    useLocale: () => TLocale;
+    useNavigate: () => LocalizedUseNavigateResult<TLocale, TDefaultFrom>;
+    usePathname: () => string;
+    useRouter: () => LocalizedRouter<TLocale, TRouter>;
+};
+
+export { type GetPathnameOptions, type LocalizedBuildLocationFn, type LocalizedPreloadRouteFn, type LocalizedRouter, type LocalizedUseNavigateResult, type NavigationFunctionsConfig, createNavigationFunctions };