intor 2.0.3 → 2.2.0

package/dist/next/index.cjs

@@ -4,9 +4,10 @@ var React7 = require('react');
 var logry = require('logry');
 var Keyv = require('keyv');
 var intorTranslator = require('intor-translator');
+var formatUrl = require('next/dist/shared/lib/router/utils/format-url');
 var NextLink = require('next/link');
 var navigation = require('next/navigation');
-var formatUrl = require('next/dist/shared/lib/router/utils/format-url');
+var headers = require('next/headers');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -47,66 +48,6 @@ function useConfig() {
   return context;
 }
 var LocaleContext = React7__namespace.createContext(void 0);
-
-// src/adapters/next/shared/utils/build-cookie-string.ts
-var buildCookieString = (cookie, locale) => {
-  const parts = [];
-  parts.push(`${cookie.name}=${encodeURIComponent(locale)}`);
-  if (cookie.maxAge) {
-    const expires = new Date(Date.now() + cookie.maxAge * 1e3).toUTCString();
-    parts.push(`expires=${expires}`);
-    parts.push(`max-age=${cookie.maxAge}`);
-  }
-  parts.push(`path=${cookie.path ?? "/"}`);
-  if (cookie.domain) {
-    parts.push(`domain=${cookie.domain}`);
-  }
-  if (cookie.sameSite) {
-    parts.push(
-      `SameSite=${cookie.sameSite[0].toUpperCase()}${cookie.sameSite.slice(1).toLowerCase()}`
-    );
-  }
-  if (cookie.secure !== false) {
-    parts.push(`Secure`);
-  }
-  return parts.join("; ");
-};
-
-// src/adapters/next/shared/utils/set-locale-cookie-browser.ts
-var setLocaleCookieBrowser = ({
-  cookie,
-  locale
-}) => {
-  if (typeof window === "undefined") return;
-  if (cookie.disabled || !cookie.autoSetCookie) return;
-  const cookieString = buildCookieString(cookie, locale);
-  document.cookie = cookieString;
-};
-
-// src/adapters/next/contexts/locale/utils/change-locale.ts
-var changeLocale = ({
-  currentLocale,
-  newLocale,
-  loaderOptions,
-  cookie,
-  setLocale,
-  refetchMessages
-}) => {
-  if (typeof document === "undefined") return;
-  const loaderType = loaderOptions?.type;
-  if (newLocale === currentLocale) return;
-  if (loaderType === "import") {
-    console.warn(
-      `[Intor] You are using dynamic import to switch languages. Please make sure to use the wrapped <Link> component to trigger a page reload, ensuring that the translation data is dynamically updated.`
-    );
-  }
-  setLocale(newLocale);
-  setLocaleCookieBrowser({ cookie, locale: newLocale });
-  document.documentElement.lang = newLocale;
-  if (loaderType === "api" && refetchMessages) {
-    void refetchMessages(newLocale);
-  }
-};
 var MessagesContext = React7__namespace.createContext(void 0);
 
 // src/modules/config/constants/cache.constants.ts
@@ -130,16 +71,22 @@ var DEFAULT_FORMATTER_CONFIG = {
 };
 function getLogger({
   id,
-  formatterConfig = DEFAULT_FORMATTER_CONFIG,
+  formatterConfig,
+  preset,
   ...options
 }) {
   const pool = getGlobalLoggerPool();
   let logger = pool.get(id);
   if (!logger) {
-    logger = logry.logry({ id, formatterConfig, ...options });
+    logger = logry.logry({
+      id,
+      formatterConfig: !formatterConfig && !preset ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
+      preset,
+      ...options
+    });
     pool.set(id, logger);
     if (pool.size > 1e3) {
-      const keys = Array.from(pool.keys());
+      const keys = [...pool.keys()];
       for (const key of keys.slice(0, 200)) pool.delete(key);
     }
   }
@@ -154,7 +101,7 @@ function getGlobalMessagesPool() {
 
 // src/shared/utils/merge-messages.ts
 var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  const result = Object.keys(staticMessages).length ? { ...staticMessages } : {};
+  const result = Object.keys(staticMessages).length > 0 ? { ...staticMessages } : {};
   for (const locale in loadedMessages) {
     const loaded = loadedMessages[locale];
     if (!result[locale]) {
@@ -173,7 +120,7 @@ var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
 var CACHE_KEY_DELIMITER = "|";
 var sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
 var normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
-  if (!key) return null;
+  if (key === null || key === void 0) return null;
   if (Array.isArray(key)) {
     if (key.length === 0) return null;
     const normalized = key.map((k) => {
@@ -197,53 +144,90 @@ var resolveNamespaces = ({
   pathname
 }) => {
   const { loader } = config;
-  const {
-    routeNamespaces = {},
-    namespaces: fallbackNamespaces
-  } = loader;
-  const { unprefixedPathname } = extractPathname({ config, pathname });
-  const standardizedPathname = standardizePathname({
-    config,
-    pathname: unprefixedPathname
-  });
+  const { routeNamespaces = {}, namespaces } = loader || {};
+  const standardizedPathname = standardizePathname({ config, pathname });
   const placeholderRemovedPathname = standardizedPathname.replace(
     `/${PREFIX_PLACEHOLDER}`,
     ""
   );
-  const defaultNamespaces = routeNamespaces.default ?? [];
-  const exactMatchNamespaces = routeNamespaces[standardizedPathname] ?? routeNamespaces[placeholderRemovedPathname];
-  if (exactMatchNamespaces) {
-    return [...defaultNamespaces, ...exactMatchNamespaces];
-  }
-  let bestMatch = "";
-  let bestNamespaces;
+  const collected = [
+    ...routeNamespaces.default || [],
+    // default
+    ...namespaces || [],
+    // default
+    ...routeNamespaces[standardizedPathname] || [],
+    // exact match
+    ...routeNamespaces[placeholderRemovedPathname] || []
+    // exact match
+  ];
   const prefixPatterns = Object.keys(routeNamespaces).filter(
     (pattern) => pattern.endsWith("/*")
   );
   for (const pattern of prefixPatterns) {
     const basePath = pattern.replace(/\/\*$/, "");
-    if (standardizedPathname.startsWith(basePath)) {
-      if (basePath.length > bestMatch.length) {
-        bestMatch = basePath;
-        bestNamespaces = routeNamespaces[pattern];
-      }
+    if (standardizedPathname.startsWith(basePath) || placeholderRemovedPathname.startsWith(basePath)) {
+      collected.push(...routeNamespaces[pattern] || []);
     }
   }
-  const matchedNamespaces = bestNamespaces ?? routeNamespaces["/*"] ?? fallbackNamespaces ?? [];
-  if (matchedNamespaces.length > 0) {
-    return [...defaultNamespaces, ...matchedNamespaces];
-  } else {
-    return [...defaultNamespaces];
+  return [...new Set(collected)];
+};
+
+// src/shared/utils/locale/normalize-locale.ts
+var toCanonical = (input) => {
+  try {
+    return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
+  } catch {
+    return;
   }
 };
+var normalizeLocale = (locale = "", supportedLocales = []) => {
+  if (!locale || supportedLocales.length === 0) return;
+  const canonicalLocale = toCanonical(locale);
+  if (!canonicalLocale) return;
+  const supportedCanonicalMap = /* @__PURE__ */ new Map();
+  for (const l of supportedLocales) {
+    const normalized = toCanonical(l);
+    if (normalized) {
+      supportedCanonicalMap.set(normalized, l);
+    }
+  }
+  if (supportedCanonicalMap.has(canonicalLocale)) {
+    return supportedCanonicalMap.get(canonicalLocale);
+  }
+  const baseLang = canonicalLocale.split("-")[0];
+  for (const [key, original] of supportedCanonicalMap) {
+    const supportedBase = key.split("-")[0];
+    if (supportedBase === baseLang) {
+      return original;
+    }
+  }
+  return;
+};
+
+// src/shared/utils/locale/resolve-preferred-locale.ts
+var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
+  if (!acceptLanguageHeader || !supportedLocales || supportedLocales.length === 0) {
+    return;
+  }
+  const supportedLocalesSet = new Set(supportedLocales);
+  const preferred = acceptLanguageHeader.split(",").map((part) => {
+    const [lang, qValue] = part.split(";");
+    const q = qValue ? Number.parseFloat(qValue.split("=")[1]) : 1;
+    if (Number.isNaN(q)) {
+      return { lang: lang.trim(), q: 0 };
+    }
+    return { lang: lang.trim(), q };
+  }).toSorted((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
+  return preferred;
+};
 
 // src/shared/utils/pathname/normalize-pathname.ts
 var normalizePathname = (rawPathname, options = {}) => {
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
-  while (start <= end && rawPathname.charCodeAt(start) <= 32) start++;
-  while (end >= start && rawPathname.charCodeAt(end) <= 32) end--;
+  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
+  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
   if (start > end) return "/";
   let result = "";
   let hasSlash = false;
@@ -254,11 +238,7 @@ var normalizePathname = (rawPathname, options = {}) => {
         hasSlash = true;
       }
     } else {
-      if (hasSlash || result === "") {
-        result += "/" + char;
-      } else {
-        result += char;
-      }
+      result += hasSlash || result === "" ? "/" + char : char;
       hasSlash = false;
     }
   }
@@ -282,8 +262,8 @@ var extractPathname = ({
   } else if (basePath && normalizedPathname === basePath) {
     prefixedPathname = "/";
   }
-  const pathParts = prefixedPathname.split("/").filter(Boolean);
-  const maybeLocale = pathParts[0] || "";
+  const pathPart = prefixedPathname.split("/").find(Boolean);
+  const maybeLocale = pathPart || "";
   const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
   let unprefixedPathname = prefixedPathname;
   if (prefix === "all") {
@@ -316,7 +296,7 @@ var standardizePathname = ({
     PREFIX_PLACEHOLDER,
     normalizePathname(pathname)
   ];
-  const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
+  const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
   return normalizePathname(standardizedPathname);
 };
 
@@ -334,13 +314,13 @@ var fetchMessages = async ({
     const params = new URLSearchParams(searchParams);
     params.append("locale", locale);
     const url = `${apiUrl}?${params.toString()}`;
-    const headers = {
+    const headers2 = {
       "Content-Type": "application/json",
       ...apiHeaders
     };
     const response = await fetch(url, {
       method: "GET",
-      headers,
+      headers: headers2,
       cache: "no-store"
     });
     if (!response.ok) {
@@ -420,16 +400,19 @@ var loadApiMessages = async ({
     logger.warn("No apiUrl provided. Skipping fetch.");
     return;
   }
-  const pool = getGlobalMessagesPool();
+  let pool;
+  if (cache.enabled) {
+    pool = getGlobalMessagesPool();
+  }
   const key = normalizeCacheKey([
     loggerOptions.id,
     basePath,
     locale,
-    [...fallbackLocales ?? []].sort().join(","),
-    [...namespaces ?? []].sort().join(",")
+    (fallbackLocales ?? []).toSorted().join(","),
+    (namespaces ?? []).toSorted().join(",")
   ]);
   if (cache.enabled && key) {
-    const cached = await pool.get(key);
+    const cached = await pool?.get(key);
     if (cached) {
       logger.debug("Messages cache hit.", { key });
       return cached;
@@ -445,7 +428,7 @@ var loadApiMessages = async ({
   });
   if (messages) {
     if (cache.enabled && key) {
-      await pool.set(key, messages, cache.ttl);
+      await pool?.set(key, messages, cache.ttl);
     }
     return messages;
   }
@@ -463,7 +446,7 @@ var loadApiMessages = async ({
       searchParams: decodeURIComponent(searchParams.toString())
     });
     if (cache.enabled && key) {
-      await pool.set(key, fallbackResult.messages, cache.ttl);
+      await pool?.set(key, fallbackResult.messages, cache.ttl);
     }
     return fallbackResult.messages;
   }
@@ -547,6 +530,8 @@ function useMessages() {
     throw new Error("useMessages must be used within a MessagesProvider");
   return context;
 }
+
+// src/adapters/next/contexts/locale/utils/use-init-lazy-load.ts
 var useInitLazyLoad = ({
   loaderOptions,
   currentLocale
@@ -561,6 +546,41 @@ var useInitLazyLoad = ({
     }
   }, [lazyLoad, currentLocale, refetchMessages, isFirstLoadedRef]);
 };
+
+// src/adapters/next/shared/utils/build-cookie-string.ts
+var buildCookieString = (cookie, locale) => {
+  const parts = [`${cookie.name}=${encodeURIComponent(locale)}`];
+  if (cookie.maxAge) {
+    const expires = new Date(Date.now() + cookie.maxAge * 1e3).toUTCString();
+    parts.push(`expires=${expires}`, `max-age=${cookie.maxAge}`);
+  }
+  parts.push(`path=${cookie.path ?? "/"}`);
+  if (cookie.domain) {
+    parts.push(`domain=${cookie.domain}`);
+  }
+  if (cookie.sameSite) {
+    parts.push(
+      `SameSite=${cookie.sameSite[0].toUpperCase()}${cookie.sameSite.slice(1).toLowerCase()}`
+    );
+  }
+  if (cookie.secure !== false) {
+    parts.push(`Secure`);
+  }
+  return parts.join("; ");
+};
+
+// src/adapters/next/shared/utils/set-locale-cookie-browser.ts
+var setLocaleCookieBrowser = ({
+  cookie,
+  locale
+}) => {
+  if (globalThis.window === void 0) return;
+  if (cookie.disabled || !cookie.autoSetCookie) return;
+  const cookieString = buildCookieString(cookie, locale);
+  document.cookie = cookieString;
+};
+
+// src/adapters/next/contexts/locale/utils/use-init-locale-cookie.ts
 var useInitLocaleCookie = ({
   config,
   locale
@@ -569,8 +589,8 @@ var useInitLocaleCookie = ({
     if (typeof document === "undefined") return;
     const { cookie, routing } = config;
     const { firstVisit } = routing;
-    const cookies = document.cookie.split(";").map((c) => c.trim());
-    const isCookieExists = cookies.some((c) => c.startsWith(`${cookie.name}=`));
+    const cookies2 = document.cookie.split(";").map((c) => c.trim());
+    const isCookieExists = cookies2.some((c) => c.startsWith(`${cookie.name}=`));
     if (isCookieExists) return;
     if (!firstVisit.redirect) return;
     if (cookie.disabled || !cookie.autoSetCookie) return;
@@ -578,6 +598,31 @@ var useInitLocaleCookie = ({
   }, []);
 };
 
+// src/adapters/next/contexts/locale/utils/change-locale.ts
+var changeLocale = ({
+  currentLocale,
+  newLocale,
+  loaderOptions,
+  cookie,
+  setLocale,
+  refetchMessages
+}) => {
+  if (typeof document === "undefined") return;
+  const loaderType = loaderOptions?.type;
+  if (newLocale === currentLocale) return;
+  if (loaderType === "import") {
+    console.warn(
+      `[Intor] You are using dynamic import to switch languages. Please make sure to use the wrapped <Link> component to trigger a page reload, ensuring that the translation data is dynamically updated.`
+    );
+  }
+  setLocale(newLocale);
+  setLocaleCookieBrowser({ cookie, locale: newLocale });
+  document.documentElement.lang = newLocale;
+  if (loaderType === "api" && refetchMessages) {
+    void refetchMessages(newLocale);
+  }
+};
+
 // src/adapters/next/contexts/locale/provider.tsx
 function LocaleProvider({
   value: { initialLocale },
@@ -676,7 +721,7 @@ function useTranslator() {
   const context = React7__namespace.useContext(TranslatorContext);
   if (!context)
     throw new Error(
-      "useIntorTranslator must be used within IntorTranslatorProvider"
+      "useTranslator must be used within IntorTranslatorProvider"
     );
   return context;
 }
@@ -689,23 +734,22 @@ var IntorProvider = ({
   return /* @__PURE__ */ React7__namespace.createElement(ConfigProvider, { value: { config, pathname } }, /* @__PURE__ */ React7__namespace.createElement(MessagesProvider, { value: { messages } }, /* @__PURE__ */ React7__namespace.createElement(LocaleProvider, { value: { initialLocale } }, /* @__PURE__ */ React7__namespace.createElement(TranslatorProvider, null, children))));
 };
 
-// src/adapters/next/hooks/use-intor/use-intor.ts
-function useIntor(preKey) {
+// src/adapters/next/hooks/use-translator/use-translator.ts
+function useTranslator2(preKey) {
   const { translator } = useTranslator();
   const { setLocale } = useLocale();
-  const sharedMethod = {
+  const props = {
     messages: translator.messages,
     locale: translator.locale,
     isLoading: translator.isLoading,
     setLocale
   };
-  if (preKey) {
-    const { hasKey, t } = translator.scoped(preKey);
-    return { ...sharedMethod, hasKey, t };
-  } else {
-    const { hasKey, t } = translator;
-    return { ...sharedMethod, hasKey, t };
-  }
+  const scoped = translator.scoped(preKey);
+  return {
+    ...props,
+    hasKey: preKey ? scoped.hasKey : translator.hasKey,
+    t: preKey ? scoped.t : translator.t
+  };
 }
 
 // src/adapters/next/shared/utils/locale-prefix-pathname.ts
@@ -725,15 +769,11 @@ var localePrefixPathname = ({
     );
   }
   if (prefix === "except-default") {
-    if (locale === config.defaultLocale) {
-      return normalizePathname(
-        standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, "")
-      );
-    } else {
-      return normalizePathname(
-        standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale)
-      );
-    }
+    return locale === config.defaultLocale ? normalizePathname(
+      standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, "")
+    ) : normalizePathname(
+      standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale)
+    );
   }
   return normalizePathname(
     standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, "")
@@ -766,10 +806,7 @@ var localizePathname = ({
   };
 };
 
-// src/adapters/next/tools/utils/should-full-reload.ts
-var shouldFullReload = (loaderOptions) => {
-  return loaderOptions?.type === "import" || loaderOptions?.type === "api" && loaderOptions.fullReload === true;
-};
+// src/adapters/next/navigation/use-pathname.ts
 var usePathname = () => {
   const { config } = useConfig();
   const { locale } = useLocale();
@@ -781,75 +818,90 @@ var usePathname = () => {
   });
   return localePrefixedPathname;
 };
-var Link = ({
-  href,
+
+// src/adapters/next/navigation/utils/should-full-reload.ts
+var shouldFullReload = ({
+  config,
+  targetPathname,
   locale,
-  children,
-  onClick,
-  ...props
+  currentLocale
 }) => {
+  const loader = config.loader;
+  if (!loader || !loader.type) return false;
+  if (loader.type === "api" && !loader.fullReload) return false;
+  const { maybeLocale, isLocalePrefixed } = extractPathname({
+    config,
+    pathname: targetPathname
+  });
+  const isDifferentLocale = locale && locale !== currentLocale || isLocalePrefixed && maybeLocale !== currentLocale;
+  return isDifferentLocale ? true : false;
+};
+
+// src/adapters/next/navigation/utils/use-locale-switch.ts
+var useLocaleSwitch = () => {
   const { config } = useConfig();
   const { locale: currentLocale, setLocale } = useLocale();
-  const targetLocale = locale || currentLocale;
   const pathname = usePathname();
-  const formattedUrl = href ? typeof href === "string" ? href : formatUrl.formatUrl(href) : void 0;
-  const { localePrefixedPathname } = localizePathname({
-    config,
-    pathname: formattedUrl ?? pathname,
-    locale: targetLocale
-  });
-  const resolvedHref = localePrefixedPathname;
-  const handleClick = (e) => {
-    onClick?.(e);
-    if (shouldFullReload(config.loader)) {
+  const resolveHref = ({
+    href,
+    locale
+  }) => {
+    const isLocaleValid = locale && config.supportedLocales?.includes(locale);
+    const targetLocale = isLocaleValid ? locale : currentLocale;
+    const targetPathname = href ?? pathname;
+    const isExternal = targetPathname.startsWith("http");
+    const resolvedHref = !isExternal ? localizePathname({
+      config,
+      pathname: targetPathname,
+      locale: targetLocale
+    }).localePrefixedPathname : targetPathname;
+    return { resolvedHref, isExternal, targetLocale, targetPathname };
+  };
+  const switchLocale = ({
+    href,
+    locale
+  }) => {
+    const { resolvedHref, isExternal, targetLocale, targetPathname } = resolveHref({ href, locale });
+    if (isExternal) return;
+    if (shouldFullReload({ config, targetPathname, locale, currentLocale })) {
       setLocaleCookieBrowser({ cookie: config.cookie, locale: targetLocale });
-      window.location.href = resolvedHref;
+      globalThis.location.href = resolvedHref;
       return;
     } else {
       setLocale(targetLocale);
     }
+    return resolvedHref;
+  };
+  return { resolveHref, switchLocale };
+};
+
+// src/adapters/next/navigation/link.tsx
+var Link = ({
+  href,
+  locale,
+  children,
+  onClick,
+  ...props
+}) => {
+  const formatted = typeof href === "string" ? href : href ? formatUrl.formatUrl(href) : void 0;
+  const { resolveHref, switchLocale } = useLocaleSwitch();
+  const { resolvedHref } = resolveHref({ href: formatted, locale });
+  const handleClick = (e) => {
+    onClick?.(e);
+    switchLocale({ href: formatted, locale });
   };
   return /* @__PURE__ */ React7__namespace.createElement(NextLink__default.default, { href: resolvedHref, onClick: handleClick, ...props }, children);
 };
 var useRouter = () => {
-  const { config } = useConfig();
-  const { locale: currentLocale, setLocale } = useLocale();
   const { push, replace, ...rest } = navigation.useRouter();
+  const { switchLocale } = useLocaleSwitch();
   const pushWithLocale = (href, options) => {
-    const targetLocale = options?.locale || currentLocale;
-    if (options?.locale) {
-      const { localePrefixedPathname } = localizePathname({
-        config,
-        pathname: href,
-        locale: targetLocale
-      });
-      href = localePrefixedPathname;
-    }
-    if (shouldFullReload(config.loader)) {
-      window.location.href = href;
-      return;
-    } else {
-      setLocale(targetLocale);
-    }
-    push(href, options);
+    const resolvedHref = switchLocale({ href, locale: options?.locale });
+    if (resolvedHref) push(resolvedHref, options);
   };
   const replaceWithLocale = (href, options) => {
-    const targetLocale = options?.locale || currentLocale;
-    if (options?.locale) {
-      const { localePrefixedPathname } = localizePathname({
-        config,
-        pathname: href,
-        locale: targetLocale
-      });
-      href = localePrefixedPathname;
-    }
-    if (shouldFullReload(config.loader)) {
-      window.location.href = href;
-      return;
-    } else {
-      setLocale(targetLocale);
-    }
-    replace(href, options);
+    const resolvedHref = switchLocale({ href, locale: options?.locale });
+    if (resolvedHref) replace(resolvedHref, options);
   };
   return {
     push: pushWithLocale,
@@ -861,10 +913,62 @@ var useRouter = () => {
 // src/adapters/next/shared/constants/pathname-header-name.ts
 var PATHNAME_HEADER_NAME = "x-intor-pathname";
 
+// src/adapters/next/server/get-i18n-context.ts
+var getI18nContext = async (config) => {
+  const baseLogger = getLogger({ id: config.id, ...config.logger });
+  const logger = baseLogger.child({ scope: "next-adapter" });
+  const cookiesStore = await headers.cookies();
+  const headersStore = await headers.headers();
+  const { defaultLocale, supportedLocales = [], cookie, routing } = config;
+  let locale;
+  if (!cookie.disabled) {
+    const localeFromCookie = cookiesStore.get(cookie.name)?.value;
+    locale = normalizeLocale(localeFromCookie, supportedLocales);
+    if (locale) {
+      logger.trace("Locale retrieved from cookie.", { locale });
+    }
+  }
+  if (!locale && routing.firstVisit.localeSource === "browser") {
+    const aLHeader = headersStore.get("accept-language") || void 0;
+    const preferredLocale = resolvePreferredLocale(aLHeader, supportedLocales);
+    locale = normalizeLocale(preferredLocale, supportedLocales);
+    logger.trace("Locale retrieved from header.", { locale });
+  }
+  const pathname = headersStore.get(PATHNAME_HEADER_NAME);
+  if (pathname) {
+    logger.trace("Pathname retrieved from header.", { pathname });
+  }
+  return {
+    locale: locale || defaultLocale,
+    pathname: pathname || ""
+  };
+};
+
+// src/adapters/next/navigation/redirect.ts
+var redirect = async ({
+  config,
+  locale,
+  url,
+  type
+}) => {
+  if (url.startsWith("http")) {
+    navigation.redirect(url);
+  }
+  const isLocaleValid = locale && config.supportedLocales?.includes(locale);
+  const { locale: detectedLocale } = await getI18nContext(config);
+  const { localePrefixedPathname } = localizePathname({
+    config,
+    pathname: url,
+    locale: isLocaleValid ? locale : detectedLocale
+  });
+  navigation.redirect(localePrefixedPathname, type);
+};
+
 exports.IntorProvider = IntorProvider;
 exports.Link = Link;
 exports.PATHNAME_HEADER_NAME = PATHNAME_HEADER_NAME;
 exports.TranslateHandlersProvider = TranslateHandlersProvider;
-exports.useIntor = useIntor;
+exports.redirect = redirect;
 exports.usePathname = usePathname;
 exports.useRouter = useRouter;
+exports.useTranslator = useTranslator2;