@better-translate/nextjs 1.0.0

package/dist/navigation.cjs

@@ -0,0 +1,374 @@
+"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 = "/[lang]";
+function hasLocale(locales, value) {
+  return locales.includes(value);
+}
+function normalizePathname(pathname) {
+  if (!pathname) {
+    return "/";
+  }
+  return pathname.startsWith("/") ? pathname : `/${pathname}`;
+}
+function getPathnameLocale(pathname, routing) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(pathname);
+  if (pathnameSegments.length < parsedTemplate.localizedSegments.length) {
+    return void 0;
+  }
+  for (let index = 0; index < parsedTemplate.localizedSegments.length; index += 1) {
+    const templateSegment = parsedTemplate.localizedSegments[index];
+    const pathnameSegment = pathnameSegments[index];
+    if (index === parsedTemplate.localeSegmentIndex) {
+      if (!pathnameSegment || !hasLocale(routing.locales, pathnameSegment)) {
+        return void 0;
+      }
+      continue;
+    }
+    if (pathnameSegment !== templateSegment) {
+      return void 0;
+    }
+  }
+  return pathnameSegments[parsedTemplate.localeSegmentIndex];
+}
+function isPathnameInScope(pathname, routing) {
+  if (getPathnameLocale(pathname, routing)) {
+    return true;
+  }
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(pathname);
+  if (pathnameSegments.length < parsedTemplate.deLocalizedSegments.length) {
+    return false;
+  }
+  for (let index = 0; index < parsedTemplate.deLocalizedSegments.length; index += 1) {
+    if (pathnameSegments[index] !== parsedTemplate.deLocalizedSegments[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function stripLocaleFromPathname(pathname, routing) {
+  const locale = getPathnameLocale(pathname, routing);
+  if (!locale) {
+    return normalizePathname(pathname);
+  }
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(pathname);
+  pathnameSegments.splice(parsedTemplate.localeSegmentIndex, 1);
+  return joinPathname(pathnameSegments);
+}
+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);
+  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 {
+    pathname: normalizePathname(pathname),
+    search,
+    hash
+  };
+}
+function isAbsoluteHref(href) {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(href) || href.startsWith("//");
+}
+function normalizeHost(host) {
+  return host.toLowerCase().replace(/:\d+$/, "");
+}
+function getDomainForLocale(routing, locale) {
+  return routing.domains?.find(
+    (domain) => getDomainLocales(domain).includes(locale)
+  );
+}
+function buildDomainAwareHref(routing, href, locale, options) {
+  if (isAbsoluteHref(href)) {
+    return {
+      href,
+      external: true
+    };
+  }
+  const { hash, pathname, search } = splitHrefString(href);
+  const isScopedPath = isPathnameInScope(pathname, routing);
+  if (!isScopedPath) {
+    return {
+      href: `${pathname}${search}${hash}`,
+      external: false
+    };
+  }
+  const localizedPathname = localizePathname(pathname, locale, routing);
+  const localizedHref = `${localizedPathname}${search}${hash}`;
+  const targetDomain = getDomainForLocale(routing, locale);
+  if (!targetDomain) {
+    return {
+      href: localizedHref,
+      external: false
+    };
+  }
+  const targetHost = normalizeHost(targetDomain.domain);
+  const currentHost = options?.currentHost ? normalizeHost(options.currentHost) : void 0;
+  const shouldUseAbsolute = options?.forceAbsolute === true || currentHost === void 0 || currentHost !== targetHost;
+  if (!shouldUseAbsolute) {
+    return {
+      href: localizedHref,
+      external: false
+    };
+  }
+  const protocol = targetDomain.protocol ?? options?.protocol ?? "https";
+  return {
+    href: `${protocol}://${targetHost}${localizedHref}`,
+    external: currentHost === void 0 ? true : currentHost !== targetHost
+  };
+}
+function parseRouteTemplate(routeTemplate) {
+  const normalizedRouteTemplate = normalizePathname(
+    routeTemplate ?? DEFAULT_ROUTE_TEMPLATE
+  );
+  const localizedSegments = splitPathname(normalizedRouteTemplate);
+  let localeSegmentIndex = -1;
+  let localeParamName = "";
+  for (let index = 0; index < localizedSegments.length; index += 1) {
+    const segment = localizedSegments[index];
+    const dynamicMatch = /^\[([^\]/]+)\]$/.exec(segment);
+    if (!dynamicMatch) {
+      continue;
+    }
+    if (localeSegmentIndex !== -1) {
+      throw new Error(
+        `Route template "${normalizedRouteTemplate}" must contain exactly one dynamic locale segment.`
+      );
+    }
+    localeSegmentIndex = index;
+    localeParamName = dynamicMatch[1];
+  }
+  if (localeSegmentIndex === -1) {
+    throw new Error(
+      `Route template "${normalizedRouteTemplate}" must contain one dynamic locale segment like "[lang]".`
+    );
+  }
+  const deLocalizedSegments = localizedSegments.filter(
+    (_, index) => index !== localeSegmentIndex
+  );
+  const scopePrefixSegments = localizedSegments.slice(0, localeSegmentIndex);
+  return {
+    deLocalizedSegments,
+    localeParamName,
+    localeSegmentIndex,
+    localizedSegments,
+    routeTemplate: normalizedRouteTemplate,
+    scopePrefix: joinPathname(scopePrefixSegments)
+  };
+}
+function splitPathname(pathname) {
+  return normalizePathname(pathname).split("/").filter(Boolean);
+}
+function joinPathname(segments) {
+  if (segments.length === 0) {
+    return "/";
+  }
+  return `/${segments.join("/")}`;
+}
+function getDomainLocales(domain) {
+  if (!domain.locales || domain.locales.length === 0) {
+    return [domain.defaultLocale];
+  }
+  if (!domain.locales.includes(domain.defaultLocale)) {
+    return [...domain.locales, domain.defaultLocale];
+  }
+  return domain.locales;
+}
+
+// src/navigation.tsx
+function createNavigationFunctions({
+  Link: LinkComponent,
+  routing,
+  useParams: useInjectedParams,
+  usePathname: useInjectedPathname,
+  useRouter: useInjectedRouter
+}) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  function getPathname({
+    href,
+    locale = routing.defaultLocale
+  }) {
+    return localizePathname(href, locale, routing);
+  }
+  function Link(rawProps) {
+    const { href, locale, ...props } = rawProps;
+    const params = useInjectedParams();
+    const activeLocale = resolveActiveLocale(
+      params,
+      routing,
+      parsedTemplate.localeParamName
+    );
+    const localizedHref = localizeLinkHref(
+      href,
+      locale ?? activeLocale,
+      routing
+    );
+    return (0, import_react.createElement)(
+      LinkComponent,
+      {
+        ...props,
+        href: localizedHref
+      }
+    );
+  }
+  function usePathname() {
+    return stripLocaleFromPathname(useInjectedPathname(), routing);
+  }
+  function useRouter() {
+    const router = useInjectedRouter();
+    const params = useInjectedParams();
+    const activeLocale = resolveActiveLocale(
+      params,
+      routing,
+      parsedTemplate.localeParamName
+    );
+    const localizedRouter = {
+      ...router,
+      push(href, options) {
+        return navigate(
+          router.push.bind(router),
+          window.location.assign.bind(window.location),
+          routing,
+          href,
+          activeLocale,
+          options
+        );
+      },
+      replace(href, options) {
+        return navigate(
+          router.replace.bind(router),
+          window.location.replace.bind(window.location),
+          routing,
+          href,
+          activeLocale,
+          options
+        );
+      }
+    };
+    if (typeof router.prefetch === "function") {
+      localizedRouter.prefetch = (href, options) => {
+        const target = buildNavigationTarget(
+          routing,
+          href,
+          activeLocale,
+          options
+        );
+        if (target.external) {
+          return void 0;
+        }
+        return router.prefetch?.(target.href, target.forwardedOptions);
+      };
+    }
+    return localizedRouter;
+  }
+  return {
+    Link,
+    getPathname,
+    usePathname,
+    useRouter
+  };
+}
+function buildNavigationTarget(routing, href, activeLocale, options) {
+  const nextLocale = options?.locale ?? activeLocale;
+  const forwardedOptions = {
+    ...options ?? {}
+  };
+  delete forwardedOptions.locale;
+  const target = buildDomainAwareHref(routing, href, nextLocale, {
+    currentHost: window.location.host,
+    protocol: window.location.protocol.replace(":", "")
+  });
+  return {
+    external: target.external,
+    forwardedOptions,
+    href: target.href
+  };
+}
+function navigate(navigateWithRouter, navigateWithDocument, routing, href, activeLocale, options) {
+  const target = buildNavigationTarget(routing, href, activeLocale, options);
+  if (target.external) {
+    navigateWithDocument(target.href);
+    return void 0;
+  }
+  return navigateWithRouter(target.href, target.forwardedOptions);
+}
+function localizeLinkHref(href, locale, routing) {
+  if (typeof href === "string") {
+    return buildDomainAwareHref(routing, href, locale, {
+      forceAbsolute: Boolean(getDomainForLocale(routing, locale))
+    }).href;
+  }
+  const pathname = typeof href.pathname === "string" ? href.pathname : "/";
+  const search = typeof href.search === "string" ? href.search : "";
+  const hash = typeof href.hash === "string" ? href.hash : "";
+  const localizedHref = buildDomainAwareHref(
+    routing,
+    `${pathname}${search}${hash}`,
+    locale,
+    {
+      forceAbsolute: Boolean(getDomainForLocale(routing, locale))
+    }
+  );
+  if (localizedHref.external) {
+    return localizedHref.href;
+  }
+  return {
+    ...href,
+    pathname: localizedHref.href
+  };
+}
+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,55 @@
+import * as react from 'react';
+import { ElementType, ComponentPropsWithoutRef } from 'react';
+import { RoutingConfig } from './index.cjs';
+
+type NavigationHref = string | {
+    hash?: string;
+    pathname?: string;
+    search?: string;
+    [key: string]: unknown;
+};
+type ParamsLike = Record<string, string | string[] | undefined>;
+type RouterLike = {
+    prefetch?: (href: string, options?: any) => unknown;
+    push: (href: string, options?: any) => unknown;
+    replace: (href: string, options?: any) => unknown;
+};
+type RouterMethodReturn<TRouter extends RouterLike, TMethod extends "push" | "replace" | "prefetch"> = TMethod extends keyof TRouter ? Extract<TRouter[TMethod], (...args: any[]) => unknown> extends (...args: any[]) => infer TReturn ? TReturn : void : void;
+type WithLocale<TLocale extends string, TOptions> = [TOptions] extends [
+    undefined
+] ? {
+    locale?: TLocale;
+} : TOptions & {
+    locale?: TLocale;
+};
+interface GetPathnameOptions<TLocale extends string> {
+    href: string;
+    locale?: TLocale;
+}
+type LocalizedLinkProps<TLocale extends string, TLink extends ElementType> = Omit<ComponentPropsWithoutRef<TLink>, "href"> & {
+    href: ComponentPropsWithoutRef<TLink> extends {
+        href: infer THref;
+    } ? THref : NavigationHref;
+    locale?: TLocale;
+};
+type LocalizedRouter<TLocale extends string, TRouter extends RouterLike> = Omit<TRouter, "prefetch" | "push" | "replace"> & {
+    push(href: string, options?: WithLocale<TLocale, Record<string, unknown>>): RouterMethodReturn<TRouter, "push">;
+    replace(href: string, options?: WithLocale<TLocale, Record<string, unknown>>): RouterMethodReturn<TRouter, "replace">;
+} & ("prefetch" extends keyof TRouter ? {
+    prefetch(href: string, options?: WithLocale<TLocale, Record<string, unknown>>): RouterMethodReturn<TRouter, "prefetch">;
+} : {});
+interface NavigationFunctionsConfig<TLocale extends string, TRouter extends RouterLike, TParams extends ParamsLike, TLink extends ElementType> {
+    Link: TLink;
+    routing: RoutingConfig<TLocale>;
+    useParams: () => TParams;
+    usePathname: () => string;
+    useRouter: () => TRouter;
+}
+declare function createNavigationFunctions<TLocale extends string, TRouter extends RouterLike, TParams extends ParamsLike, TLink extends ElementType>({ Link: LinkComponent, routing, useParams: useInjectedParams, usePathname: useInjectedPathname, useRouter: useInjectedRouter, }: NavigationFunctionsConfig<TLocale, TRouter, TParams, TLink>): {
+    Link: (rawProps: LocalizedLinkProps<TLocale, TLink>) => react.ReactElement<any, string | react.JSXElementConstructor<any>>;
+    getPathname: ({ href, locale, }: GetPathnameOptions<TLocale>) => string;
+    usePathname: () => string;
+    useRouter: () => LocalizedRouter<TLocale, TRouter>;
+};
+
+export { type GetPathnameOptions, type LocalizedLinkProps, type LocalizedRouter, type NavigationFunctionsConfig, createNavigationFunctions };

package/dist/navigation.d.ts

@@ -0,0 +1,55 @@
+import * as react from 'react';
+import { ElementType, ComponentPropsWithoutRef } from 'react';
+import { RoutingConfig } from './index.js';
+
+type NavigationHref = string | {
+    hash?: string;
+    pathname?: string;
+    search?: string;
+    [key: string]: unknown;
+};
+type ParamsLike = Record<string, string | string[] | undefined>;
+type RouterLike = {
+    prefetch?: (href: string, options?: any) => unknown;
+    push: (href: string, options?: any) => unknown;
+    replace: (href: string, options?: any) => unknown;
+};
+type RouterMethodReturn<TRouter extends RouterLike, TMethod extends "push" | "replace" | "prefetch"> = TMethod extends keyof TRouter ? Extract<TRouter[TMethod], (...args: any[]) => unknown> extends (...args: any[]) => infer TReturn ? TReturn : void : void;
+type WithLocale<TLocale extends string, TOptions> = [TOptions] extends [
+    undefined
+] ? {
+    locale?: TLocale;
+} : TOptions & {
+    locale?: TLocale;
+};
+interface GetPathnameOptions<TLocale extends string> {
+    href: string;
+    locale?: TLocale;
+}
+type LocalizedLinkProps<TLocale extends string, TLink extends ElementType> = Omit<ComponentPropsWithoutRef<TLink>, "href"> & {
+    href: ComponentPropsWithoutRef<TLink> extends {
+        href: infer THref;
+    } ? THref : NavigationHref;
+    locale?: TLocale;
+};
+type LocalizedRouter<TLocale extends string, TRouter extends RouterLike> = Omit<TRouter, "prefetch" | "push" | "replace"> & {
+    push(href: string, options?: WithLocale<TLocale, Record<string, unknown>>): RouterMethodReturn<TRouter, "push">;
+    replace(href: string, options?: WithLocale<TLocale, Record<string, unknown>>): RouterMethodReturn<TRouter, "replace">;
+} & ("prefetch" extends keyof TRouter ? {
+    prefetch(href: string, options?: WithLocale<TLocale, Record<string, unknown>>): RouterMethodReturn<TRouter, "prefetch">;
+} : {});
+interface NavigationFunctionsConfig<TLocale extends string, TRouter extends RouterLike, TParams extends ParamsLike, TLink extends ElementType> {
+    Link: TLink;
+    routing: RoutingConfig<TLocale>;
+    useParams: () => TParams;
+    usePathname: () => string;
+    useRouter: () => TRouter;
+}
+declare function createNavigationFunctions<TLocale extends string, TRouter extends RouterLike, TParams extends ParamsLike, TLink extends ElementType>({ Link: LinkComponent, routing, useParams: useInjectedParams, usePathname: useInjectedPathname, useRouter: useInjectedRouter, }: NavigationFunctionsConfig<TLocale, TRouter, TParams, TLink>): {
+    Link: (rawProps: LocalizedLinkProps<TLocale, TLink>) => react.ReactElement<any, string | react.JSXElementConstructor<any>>;
+    getPathname: ({ href, locale, }: GetPathnameOptions<TLocale>) => string;
+    usePathname: () => string;
+    useRouter: () => LocalizedRouter<TLocale, TRouter>;
+};
+
+export { type GetPathnameOptions, type LocalizedLinkProps, type LocalizedRouter, type NavigationFunctionsConfig, createNavigationFunctions };

package/dist/navigation.js

@@ -0,0 +1,163 @@
+import {
+  buildDomainAwareHref,
+  getDomainForLocale,
+  localizePathname,
+  parseRouteTemplate,
+  stripLocaleFromPathname
+} from "./chunk-VW2LUTE7.js";
+
+// src/navigation.tsx
+import {
+  createElement
+} from "react";
+function createNavigationFunctions({
+  Link: LinkComponent,
+  routing,
+  useParams: useInjectedParams,
+  usePathname: useInjectedPathname,
+  useRouter: useInjectedRouter
+}) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  function getPathname({
+    href,
+    locale = routing.defaultLocale
+  }) {
+    return localizePathname(href, locale, routing);
+  }
+  function Link(rawProps) {
+    const { href, locale, ...props } = rawProps;
+    const params = useInjectedParams();
+    const activeLocale = resolveActiveLocale(
+      params,
+      routing,
+      parsedTemplate.localeParamName
+    );
+    const localizedHref = localizeLinkHref(
+      href,
+      locale ?? activeLocale,
+      routing
+    );
+    return createElement(
+      LinkComponent,
+      {
+        ...props,
+        href: localizedHref
+      }
+    );
+  }
+  function usePathname() {
+    return stripLocaleFromPathname(useInjectedPathname(), routing);
+  }
+  function useRouter() {
+    const router = useInjectedRouter();
+    const params = useInjectedParams();
+    const activeLocale = resolveActiveLocale(
+      params,
+      routing,
+      parsedTemplate.localeParamName
+    );
+    const localizedRouter = {
+      ...router,
+      push(href, options) {
+        return navigate(
+          router.push.bind(router),
+          window.location.assign.bind(window.location),
+          routing,
+          href,
+          activeLocale,
+          options
+        );
+      },
+      replace(href, options) {
+        return navigate(
+          router.replace.bind(router),
+          window.location.replace.bind(window.location),
+          routing,
+          href,
+          activeLocale,
+          options
+        );
+      }
+    };
+    if (typeof router.prefetch === "function") {
+      localizedRouter.prefetch = (href, options) => {
+        const target = buildNavigationTarget(
+          routing,
+          href,
+          activeLocale,
+          options
+        );
+        if (target.external) {
+          return void 0;
+        }
+        return router.prefetch?.(target.href, target.forwardedOptions);
+      };
+    }
+    return localizedRouter;
+  }
+  return {
+    Link,
+    getPathname,
+    usePathname,
+    useRouter
+  };
+}
+function buildNavigationTarget(routing, href, activeLocale, options) {
+  const nextLocale = options?.locale ?? activeLocale;
+  const forwardedOptions = {
+    ...options ?? {}
+  };
+  delete forwardedOptions.locale;
+  const target = buildDomainAwareHref(routing, href, nextLocale, {
+    currentHost: window.location.host,
+    protocol: window.location.protocol.replace(":", "")
+  });
+  return {
+    external: target.external,
+    forwardedOptions,
+    href: target.href
+  };
+}
+function navigate(navigateWithRouter, navigateWithDocument, routing, href, activeLocale, options) {
+  const target = buildNavigationTarget(routing, href, activeLocale, options);
+  if (target.external) {
+    navigateWithDocument(target.href);
+    return void 0;
+  }
+  return navigateWithRouter(target.href, target.forwardedOptions);
+}
+function localizeLinkHref(href, locale, routing) {
+  if (typeof href === "string") {
+    return buildDomainAwareHref(routing, href, locale, {
+      forceAbsolute: Boolean(getDomainForLocale(routing, locale))
+    }).href;
+  }
+  const pathname = typeof href.pathname === "string" ? href.pathname : "/";
+  const search = typeof href.search === "string" ? href.search : "";
+  const hash = typeof href.hash === "string" ? href.hash : "";
+  const localizedHref = buildDomainAwareHref(
+    routing,
+    `${pathname}${search}${hash}`,
+    locale,
+    {
+      forceAbsolute: Boolean(getDomainForLocale(routing, locale))
+    }
+  );
+  if (localizedHref.external) {
+    return localizedHref.href;
+  }
+  return {
+    ...href,
+    pathname: localizedHref.href
+  };
+}
+function resolveActiveLocale(params, routing, localeParamName) {
+  const localeParam = params[localeParamName];
+  if (typeof localeParam === "string" && routing.locales.includes(localeParam)) {
+    return localeParam;
+  }
+  return routing.defaultLocale;
+}
+export {
+  createNavigationFunctions
+};