@better-translate/nextjs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jorge Alvarenga
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @better-translate/nextjs
+
+`@better-translate/nextjs` adds locale routing, request helpers, navigation helpers, and proxy support for Next.js App Router. Use it with `@better-translate/core`, and add `@better-translate/react` only if you need client-side hooks.
+
+Full docs: [better-translate-placeholder.com/en/docs/adapters/nextjs](https://better-translate-placeholder.com/en/docs/adapters/nextjs)

package/dist/chunk-VW2LUTE7.js

@@ -0,0 +1,291 @@
+// src/shared.ts
+var DEFAULT_ROUTE_TEMPLATE = "/[lang]";
+function hasLocale(locales, value) {
+  return locales.includes(value);
+}
+function defineRouting(config) {
+  const routeTemplate = config.routeTemplate ?? DEFAULT_ROUTE_TEMPLATE;
+  validateRouting({
+    ...config,
+    routeTemplate
+  });
+  const domains = config.domains?.map(
+    (domain) => Object.freeze({
+      ...domain,
+      locales: domain.locales ? [...domain.locales] : void 0
+    })
+  );
+  return Object.freeze({
+    locales: [...config.locales],
+    defaultLocale: config.defaultLocale,
+    domains,
+    routeTemplate
+  });
+}
+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 getLocaleFromDomain(routing, host) {
+  const normalizedHost = normalizeHost(host);
+  return routing.domains?.find(
+    (domain) => normalizeHost(domain.domain) === normalizedHost
+  )?.defaultLocale;
+}
+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 validateRouting(config) {
+  if (config.locales.length === 0) {
+    throw new Error("defineRouting(...) requires at least one locale.");
+  }
+  parseRouteTemplate(config.routeTemplate);
+  const localeSet = /* @__PURE__ */ new Set();
+  for (const locale of config.locales) {
+    if (localeSet.has(locale)) {
+      throw new Error(`Duplicate locale "${locale}" found in routing config.`);
+    }
+    localeSet.add(locale);
+  }
+  if (!hasLocale(config.locales, config.defaultLocale)) {
+    throw new Error(
+      `The default locale "${config.defaultLocale}" is not included in locales.`
+    );
+  }
+  if (!config.domains) {
+    return;
+  }
+  const domainSet = /* @__PURE__ */ new Set();
+  const localeToDomain = /* @__PURE__ */ new Map();
+  for (const domain of config.domains) {
+    const normalizedDomain = normalizeHost(domain.domain);
+    if (!normalizedDomain) {
+      throw new Error("Routing domains must include a non-empty domain value.");
+    }
+    if (domainSet.has(normalizedDomain)) {
+      throw new Error(
+        `Duplicate domain "${normalizedDomain}" found in routing config.`
+      );
+    }
+    domainSet.add(normalizedDomain);
+    if (!hasLocale(config.locales, domain.defaultLocale)) {
+      throw new Error(
+        `The domain default locale "${domain.defaultLocale}" is not included in locales.`
+      );
+    }
+    const domainLocales = getDomainLocales(domain);
+    if (!domainLocales.includes(domain.defaultLocale)) {
+      throw new Error(
+        `The domain "${domain.domain}" must include its default locale "${domain.defaultLocale}".`
+      );
+    }
+    for (const locale of domainLocales) {
+      if (!hasLocale(config.locales, locale)) {
+        throw new Error(
+          `The domain "${domain.domain}" includes unsupported locale "${locale}".`
+        );
+      }
+      const existingDomain = localeToDomain.get(locale);
+      if (existingDomain && existingDomain !== normalizedDomain) {
+        throw new Error(
+          `Locale "${locale}" is assigned to multiple domains: "${existingDomain}" and "${normalizedDomain}".`
+        );
+      }
+      localeToDomain.set(locale, normalizedDomain);
+    }
+  }
+}
+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;
+}
+
+export {
+  hasLocale,
+  defineRouting,
+  getPathnameLocale,
+  isPathnameInScope,
+  stripLocaleFromPathname,
+  localizePathname,
+  getDomainForLocale,
+  getLocaleFromDomain,
+  buildDomainAwareHref,
+  parseRouteTemplate
+};

package/dist/index.cjs

@@ -0,0 +1,267 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  defineRouting: () => defineRouting,
+  getDomainForLocale: () => getDomainForLocale,
+  getLocaleFromDomain: () => getLocaleFromDomain,
+  getPathnameLocale: () => getPathnameLocale,
+  hasLocale: () => hasLocale,
+  isPathnameInScope: () => isPathnameInScope,
+  localizePathname: () => localizePathname,
+  stripLocaleFromPathname: () => stripLocaleFromPathname
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/shared.ts
+var DEFAULT_ROUTE_TEMPLATE = "/[lang]";
+function hasLocale(locales, value) {
+  return locales.includes(value);
+}
+function defineRouting(config) {
+  const routeTemplate = config.routeTemplate ?? DEFAULT_ROUTE_TEMPLATE;
+  validateRouting({
+    ...config,
+    routeTemplate
+  });
+  const domains = config.domains?.map(
+    (domain) => Object.freeze({
+      ...domain,
+      locales: domain.locales ? [...domain.locales] : void 0
+    })
+  );
+  return Object.freeze({
+    locales: [...config.locales],
+    defaultLocale: config.defaultLocale,
+    domains,
+    routeTemplate
+  });
+}
+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 normalizeHost(host) {
+  return host.toLowerCase().replace(/:\d+$/, "");
+}
+function getDomainForLocale(routing, locale) {
+  return routing.domains?.find(
+    (domain) => getDomainLocales(domain).includes(locale)
+  );
+}
+function getLocaleFromDomain(routing, host) {
+  const normalizedHost = normalizeHost(host);
+  return routing.domains?.find(
+    (domain) => normalizeHost(domain.domain) === normalizedHost
+  )?.defaultLocale;
+}
+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 validateRouting(config) {
+  if (config.locales.length === 0) {
+    throw new Error("defineRouting(...) requires at least one locale.");
+  }
+  parseRouteTemplate(config.routeTemplate);
+  const localeSet = /* @__PURE__ */ new Set();
+  for (const locale of config.locales) {
+    if (localeSet.has(locale)) {
+      throw new Error(`Duplicate locale "${locale}" found in routing config.`);
+    }
+    localeSet.add(locale);
+  }
+  if (!hasLocale(config.locales, config.defaultLocale)) {
+    throw new Error(
+      `The default locale "${config.defaultLocale}" is not included in locales.`
+    );
+  }
+  if (!config.domains) {
+    return;
+  }
+  const domainSet = /* @__PURE__ */ new Set();
+  const localeToDomain = /* @__PURE__ */ new Map();
+  for (const domain of config.domains) {
+    const normalizedDomain = normalizeHost(domain.domain);
+    if (!normalizedDomain) {
+      throw new Error("Routing domains must include a non-empty domain value.");
+    }
+    if (domainSet.has(normalizedDomain)) {
+      throw new Error(
+        `Duplicate domain "${normalizedDomain}" found in routing config.`
+      );
+    }
+    domainSet.add(normalizedDomain);
+    if (!hasLocale(config.locales, domain.defaultLocale)) {
+      throw new Error(
+        `The domain default locale "${domain.defaultLocale}" is not included in locales.`
+      );
+    }
+    const domainLocales = getDomainLocales(domain);
+    if (!domainLocales.includes(domain.defaultLocale)) {
+      throw new Error(
+        `The domain "${domain.domain}" must include its default locale "${domain.defaultLocale}".`
+      );
+    }
+    for (const locale of domainLocales) {
+      if (!hasLocale(config.locales, locale)) {
+        throw new Error(
+          `The domain "${domain.domain}" includes unsupported locale "${locale}".`
+        );
+      }
+      const existingDomain = localeToDomain.get(locale);
+      if (existingDomain && existingDomain !== normalizedDomain) {
+        throw new Error(
+          `Locale "${locale}" is assigned to multiple domains: "${existingDomain}" and "${normalizedDomain}".`
+        );
+      }
+      localeToDomain.set(locale, normalizedDomain);
+    }
+  }
+}
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineRouting,
+  getDomainForLocale,
+  getLocaleFromDomain,
+  getPathnameLocale,
+  hasLocale,
+  isPathnameInScope,
+  localizePathname,
+  stripLocaleFromPathname
+});

package/dist/index.d.cts

@@ -0,0 +1,33 @@
+interface RoutingDomain<TLocale extends string> {
+    domain: string;
+    defaultLocale: TLocale;
+    locales?: readonly TLocale[];
+    protocol?: "http" | "https";
+}
+interface RoutingConfig<TLocale extends string> {
+    locales: readonly TLocale[];
+    defaultLocale: TLocale;
+    domains?: readonly RoutingDomain<TLocale>[];
+    routeTemplate?: string;
+}
+type DefinedRouting<TLocale extends string, TDefaultLocale extends TLocale = TLocale> = Readonly<{
+    locales: readonly TLocale[];
+    defaultLocale: TDefaultLocale;
+    domains?: readonly RoutingDomain<TLocale>[];
+    routeTemplate: string;
+}>;
+declare function hasLocale<TLocale extends string>(locales: readonly TLocale[], value: string): value is TLocale;
+declare function defineRouting<const TLocales extends readonly string[], const TDefaultLocale extends TLocales[number]>(config: {
+    locales: TLocales;
+    defaultLocale: TDefaultLocale;
+    domains?: readonly RoutingDomain<TLocales[number]>[];
+    routeTemplate?: string;
+}): DefinedRouting<TLocales[number], TDefaultLocale>;
+declare function getPathnameLocale<TLocale extends string>(pathname: string, routing: RoutingConfig<TLocale>): TLocale | undefined;
+declare function isPathnameInScope<TLocale extends string>(pathname: string, routing: RoutingConfig<TLocale>): boolean;
+declare function stripLocaleFromPathname<TLocale extends string>(pathname: string, routing: RoutingConfig<TLocale>): string;
+declare function localizePathname<TLocale extends string>(pathname: string, locale: TLocale, routing: RoutingConfig<TLocale>): string;
+declare function getDomainForLocale<TLocale extends string>(routing: RoutingConfig<TLocale>, locale: TLocale): RoutingDomain<TLocale> | undefined;
+declare function getLocaleFromDomain<TLocale extends string>(routing: RoutingConfig<TLocale>, host: string): TLocale | undefined;
+
+export { type DefinedRouting, type RoutingConfig, type RoutingDomain, defineRouting, getDomainForLocale, getLocaleFromDomain, getPathnameLocale, hasLocale, isPathnameInScope, localizePathname, stripLocaleFromPathname };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+interface RoutingDomain<TLocale extends string> {
+    domain: string;
+    defaultLocale: TLocale;
+    locales?: readonly TLocale[];
+    protocol?: "http" | "https";
+}
+interface RoutingConfig<TLocale extends string> {
+    locales: readonly TLocale[];
+    defaultLocale: TLocale;
+    domains?: readonly RoutingDomain<TLocale>[];
+    routeTemplate?: string;
+}
+type DefinedRouting<TLocale extends string, TDefaultLocale extends TLocale = TLocale> = Readonly<{
+    locales: readonly TLocale[];
+    defaultLocale: TDefaultLocale;
+    domains?: readonly RoutingDomain<TLocale>[];
+    routeTemplate: string;
+}>;
+declare function hasLocale<TLocale extends string>(locales: readonly TLocale[], value: string): value is TLocale;
+declare function defineRouting<const TLocales extends readonly string[], const TDefaultLocale extends TLocales[number]>(config: {
+    locales: TLocales;
+    defaultLocale: TDefaultLocale;
+    domains?: readonly RoutingDomain<TLocales[number]>[];
+    routeTemplate?: string;
+}): DefinedRouting<TLocales[number], TDefaultLocale>;
+declare function getPathnameLocale<TLocale extends string>(pathname: string, routing: RoutingConfig<TLocale>): TLocale | undefined;
+declare function isPathnameInScope<TLocale extends string>(pathname: string, routing: RoutingConfig<TLocale>): boolean;
+declare function stripLocaleFromPathname<TLocale extends string>(pathname: string, routing: RoutingConfig<TLocale>): string;
+declare function localizePathname<TLocale extends string>(pathname: string, locale: TLocale, routing: RoutingConfig<TLocale>): string;
+declare function getDomainForLocale<TLocale extends string>(routing: RoutingConfig<TLocale>, locale: TLocale): RoutingDomain<TLocale> | undefined;
+declare function getLocaleFromDomain<TLocale extends string>(routing: RoutingConfig<TLocale>, host: string): TLocale | undefined;
+
+export { type DefinedRouting, type RoutingConfig, type RoutingDomain, defineRouting, getDomainForLocale, getLocaleFromDomain, getPathnameLocale, hasLocale, isPathnameInScope, localizePathname, stripLocaleFromPathname };

package/dist/index.js

@@ -0,0 +1,20 @@
+import {
+  defineRouting,
+  getDomainForLocale,
+  getLocaleFromDomain,
+  getPathnameLocale,
+  hasLocale,
+  isPathnameInScope,
+  localizePathname,
+  stripLocaleFromPathname
+} from "./chunk-VW2LUTE7.js";
+export {
+  defineRouting,
+  getDomainForLocale,
+  getLocaleFromDomain,
+  getPathnameLocale,
+  hasLocale,
+  isPathnameInScope,
+  localizePathname,
+  stripLocaleFromPathname
+};