intor 2.2.13 → 2.2.15

package/dist/next/index.js

@@ -1,907 +0,0 @@
-import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
-import NextLink from 'next/link';
-import * as React7 from 'react';
-import { usePathname as usePathname$1, useRouter as useRouter$1, redirect as redirect$1 } from 'next/navigation';
-import merge from 'lodash.merge';
-import { jsx } from 'react/jsx-runtime';
-import { logry } from 'logry';
-import Keyv from 'keyv';
-import { cookies, headers } from 'next/headers';
-import { Translator } from 'intor-translator';
-
-// src/adapters/next/navigation/link.tsx
-
-// src/shared/constants/prefix-placeholder.ts
-var PREFIX_PLACEHOLDER = "{locale}";
-var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  if (!loadedMessages) return { ...staticMessages };
-  return merge({}, staticMessages, loadedMessages);
-};
-
-// src/shared/utils/normalize-cache-key.ts
-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 === null || key === void 0) return null;
-  if (Array.isArray(key)) {
-    if (key.length === 0) return null;
-    const normalized = key.map((k) => {
-      if (k === null) return "__null";
-      if (k === void 0) return "__undefined";
-      if (typeof k === "boolean") return k ? "__true" : "__false";
-      return sanitize(String(k));
-    });
-    return normalized.join(delimiter);
-  }
-  if (typeof key === "boolean") return key ? "__true" : "__false";
-  return String(key);
-};
-
-// src/shared/utils/resolve-namespaces.ts
-var resolveNamespaces = ({
-  config,
-  pathname
-}) => {
-  const { loader } = config;
-  const { routeNamespaces = {}, namespaces } = loader || {};
-  if (Object.keys(routeNamespaces).length === 0 && !namespaces)
-    return void 0;
-  const standardizedPathname = standardizePathname({ config, pathname });
-  const placeholderRemovedPathname = standardizedPathname.replace(
-    `/${PREFIX_PLACEHOLDER}`,
-    ""
-  );
-  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) || placeholderRemovedPathname.startsWith(basePath)) {
-      collected.push(...routeNamespaces[pattern] || []);
-    }
-  }
-  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.codePointAt(start) ?? 0) <= 32) start++;
-  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
-  if (start > end) return "/";
-  let result = "";
-  let hasSlash = false;
-  for (let i = start; i <= end; i++) {
-    const char = rawPathname[i];
-    if (char === "/") {
-      if (!hasSlash) {
-        hasSlash = true;
-      }
-    } else {
-      result += hasSlash || result === "" ? "/" + char : char;
-      hasSlash = false;
-    }
-  }
-  if (options.removeLeadingSlash && result.startsWith("/")) {
-    result = result.slice(1);
-  }
-  return result || "/";
-};
-
-// src/shared/utils/pathname/extract-pathname.ts
-var extractPathname = ({
-  config,
-  pathname: rawPathname
-}) => {
-  const { routing, defaultLocale } = config;
-  const { basePath, prefix } = routing;
-  const normalizedPathname = normalizePathname(rawPathname);
-  let prefixedPathname = normalizedPathname;
-  if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-    prefixedPathname = normalizedPathname.slice(basePath.length) || "/";
-  } else if (basePath && normalizedPathname === basePath) {
-    prefixedPathname = "/";
-  }
-  const pathPart = prefixedPathname.split("/").find(Boolean);
-  const maybeLocale = pathPart || "";
-  const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
-  let unprefixedPathname = prefixedPathname;
-  if (prefix === "all") {
-    if (isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  } else if (prefix === "except-default") {
-    if (maybeLocale && maybeLocale !== defaultLocale && isLocalePrefixed) {
-      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
-    }
-  }
-  return {
-    basePath,
-    prefixedPathname,
-    unprefixedPathname,
-    maybeLocale,
-    isLocalePrefixed: Boolean(isLocalePrefixed)
-  };
-};
-
-// src/shared/utils/pathname/standardize-pathname.ts
-var standardizePathname = ({
-  config,
-  pathname
-}) => {
-  const { routing } = config;
-  const { basePath } = routing;
-  const parts = [
-    normalizePathname(basePath),
-    PREFIX_PLACEHOLDER,
-    normalizePathname(pathname)
-  ];
-  const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-  return normalizePathname(standardizedPathname);
-};
-
-// src/adapters/next/shared/utils/locale-prefix-pathname.ts
-var localePrefixPathname = ({
-  config,
-  pathname: standardizedPathname,
-  locale
-}) => {
-  const { routing } = config;
-  const { prefix } = routing;
-  if (prefix !== "none" && !locale) {
-    throw new Error('No locale when using prefix "all", "except-default"');
-  }
-  if (prefix === "all") {
-    return normalizePathname(
-      standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale)
-    );
-  }
-  if (prefix === "except-default") {
-    return locale === config.defaultLocale ? normalizePathname(
-      standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, "")
-    ) : normalizePathname(
-      standardizedPathname.replaceAll(PREFIX_PLACEHOLDER, locale)
-    );
-  }
-  return normalizePathname(
-    standardizedPathname.replaceAll(`/${PREFIX_PLACEHOLDER}`, "")
-  );
-};
-
-// src/adapters/next/shared/utils/localize-pathname.ts
-var localizePathname = ({
-  config,
-  pathname: rawPathname,
-  locale
-}) => {
-  const { unprefixedPathname } = extractPathname({
-    config,
-    pathname: rawPathname
-  });
-  const standardizedPathname = standardizePathname({
-    config,
-    pathname: unprefixedPathname
-  });
-  const localePrefixedPathname = localePrefixPathname({
-    config,
-    pathname: standardizedPathname,
-    locale
-  });
-  return {
-    unprefixedPathname,
-    standardizedPathname,
-    localePrefixedPathname
-  };
-};
-var ConfigContext = React7.createContext(void 0);
-function ConfigProvider({
-  value: { config, pathname },
-  children
-}) {
-  const value = React7.useMemo(() => ({ config, pathname }), [config, pathname]);
-  return /* @__PURE__ */ jsx(ConfigContext.Provider, { value, children });
-}
-function useConfig() {
-  const context = React7.useContext(ConfigContext);
-  if (!context) throw new Error("useConfig must be used within ConfigProvider");
-  return context;
-}
-
-// src/shared/utils/client/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/shared/utils/client/set-locale-cookie-browser.ts
-var setLocaleCookieBrowser = ({
-  cookie,
-  locale
-}) => {
-  if (typeof document === "undefined") return;
-  if (!cookie.enabled || !cookie.autoSetCookie) return;
-  const cookieString = buildCookieString(cookie, locale);
-  document.cookie = cookieString;
-};
-
-// src/client/react/contexts/locale/utils/use-init-locale-cookie.ts
-var useInitLocaleCookie = ({
-  config,
-  locale
-}) => {
-  React7.useEffect(() => {
-    if (typeof document === "undefined") return;
-    const { cookie, routing } = config;
-    const { firstVisit } = routing;
-    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.enabled || !cookie.autoSetCookie) return;
-    setLocaleCookieBrowser({ cookie, locale });
-  }, []);
-};
-
-// src/config/constants/cache.constants.ts
-var DEFAULT_CACHE_OPTIONS = {
-  enabled: process.env.NODE_ENV === "production",
-  ttl: 60 * 60 * 1e3
-  // 1 hour
-};
-
-// src/server/shared/logger/global-logger-pool.ts
-function getGlobalLoggerPool() {
-  if (!globalThis.__INTOR_LOGGER_POOL__) {
-    globalThis.__INTOR_LOGGER_POOL__ = /* @__PURE__ */ new Map();
-  }
-  return globalThis.__INTOR_LOGGER_POOL__;
-}
-
-// src/server/shared/logger/get-logger.ts
-var DEFAULT_FORMATTER_CONFIG = {
-  node: { meta: { compact: true }, lineBreaksAfter: 1 }
-};
-function getLogger({
-  id = "default",
-  formatterConfig,
-  preset,
-  ...options
-}) {
-  const pool = getGlobalLoggerPool();
-  let logger = pool.get(id);
-  const useDefault = !formatterConfig && !preset;
-  if (!logger) {
-    logger = logry({
-      id,
-      formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
-      preset,
-      ...options
-    });
-    pool.set(id, logger);
-    if (pool.size > 1e3) {
-      const keys = [...pool.keys()];
-      for (const key of keys.slice(0, 200)) pool.delete(key);
-    }
-  }
-  return logger;
-}
-
-// src/server/messages/shared/utils/is-valid-messages.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isValidMessages(value) {
-  if (!isPlainObject(value)) return false;
-  const stack = [value];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    for (const v of Object.values(current)) {
-      if (typeof v === "string") continue;
-      if (isPlainObject(v)) {
-        stack.push(v);
-      } else {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function getGlobalMessagesPool() {
-  if (!globalThis.__INTOR_MESSAGES_POOL__) {
-    globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
-  }
-  return globalThis.__INTOR_MESSAGES_POOL__;
-}
-
-// src/server/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.ts
-var fetchLocaleMessages = async ({
-  remoteUrl,
-  remoteHeaders,
-  searchParams,
-  locale,
-  extraOptions: { loggerOptions } = {}
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
-  try {
-    const params = new URLSearchParams(searchParams);
-    params.append("locale", locale);
-    const url = `${remoteUrl}?${params.toString()}`;
-    const headers2 = {
-      "Content-Type": "application/json",
-      ...remoteHeaders
-    };
-    const response = await fetch(url, {
-      method: "GET",
-      headers: headers2,
-      cache: "no-store"
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP error ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!isValidMessages(data[locale])) {
-      throw new Error("JSON file does not match NamespaceMessages structure");
-    }
-    return data;
-  } catch (error) {
-    logger.warn("Fetching locale messages failed.", {
-      locale,
-      remoteUrl,
-      searchParams: decodeURIComponent(searchParams.toString()),
-      error
-    });
-    return;
-  }
-};
-
-// src/server/messages/load-remote-messages/fetch-locale-messages/utils/build-search-params.ts
-var buildSearchParams = (params) => {
-  const searchParams = new URLSearchParams();
-  const appendParam = (key, value) => {
-    if (value === void 0 || value === null) return;
-    if (Array.isArray(value) && value.length === 0) return;
-    if (Array.isArray(value)) {
-      value.forEach((v) => v && searchParams.append(key, v));
-    } else {
-      searchParams.append(key, value);
-    }
-  };
-  Object.entries(params).forEach(([key, value]) => {
-    appendParam(key, value);
-  });
-  return searchParams;
-};
-
-// src/server/messages/load-remote-messages/load-remote-messages.ts
-var loadRemoteMessages = async ({
-  pool = getGlobalMessagesPool(),
-  rootDir,
-  remoteUrl,
-  remoteHeaders,
-  locale,
-  fallbackLocales = [],
-  namespaces = [],
-  extraOptions: {
-    cacheOptions = DEFAULT_CACHE_OPTIONS,
-    loggerOptions = { id: "default" }
-  } = {},
-  allowCacheWrite
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-remote-messages" });
-  const start = performance.now();
-  logger.debug("Loading remote messages from api.", { remoteUrl });
-  const key = normalizeCacheKey([
-    loggerOptions.id,
-    "loaderType:remote",
-    rootDir,
-    locale,
-    (fallbackLocales ?? []).toSorted().join(","),
-    (namespaces ?? []).toSorted().join(",")
-  ]);
-  if (cacheOptions.enabled && key) {
-    const cached = await pool?.get(key);
-    if (cached) {
-      logger.debug("Messages cache hit.", { key });
-      return cached;
-    }
-  }
-  const searchParams = buildSearchParams({ rootDir, namespaces });
-  const candidateLocales = [locale, ...fallbackLocales || []];
-  let messages;
-  for (const candidateLocale of candidateLocales) {
-    try {
-      const result = await fetchLocaleMessages({
-        remoteUrl,
-        remoteHeaders,
-        searchParams,
-        locale: candidateLocale,
-        extraOptions: { loggerOptions }
-      });
-      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
-        messages = result;
-        break;
-      }
-    } catch (error) {
-      logger.error("Failed to fetch locale messages.", {
-        locale: candidateLocale,
-        error
-      });
-    }
-  }
-  if (allowCacheWrite && cacheOptions.enabled && key && messages) {
-    await pool?.set(key, messages, cacheOptions.ttl);
-  }
-  const end = performance.now();
-  const duration = Math.round(end - start);
-  logger.trace("Finished loading remote messages.", {
-    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
-    duration: `${duration} ms`
-  });
-  return messages;
-};
-
-// src/client/react/contexts/messages/utils/use-refetch-messages.ts
-var useRefetchMessages = ({
-  config,
-  pathname,
-  setLoadedMessages,
-  setIsLoadingMessages
-}) => {
-  const { messages: staticMessages, loader } = config;
-  const namespaces = React7.useMemo(() => {
-    if (!loader) return [];
-    return resolveNamespaces({ config, pathname });
-  }, [config, pathname]);
-  const refetchMessages = React7.useCallback(
-    async (newLocale) => {
-      if (loader?.type === "remote") {
-        setIsLoadingMessages(true);
-        const loadedMessages = await loadRemoteMessages({
-          rootDir: loader.rootDir,
-          remoteUrl: loader.remoteUrl,
-          remoteHeaders: loader.remoteHeaders,
-          locale: newLocale,
-          fallbackLocales: config.fallbackLocales[newLocale] || [],
-          namespaces,
-          extraOptions: {
-            cacheOptions: config.cache,
-            loggerOptions: { id: config.id }
-          }
-        });
-        const messages = mergeMessages(staticMessages, loadedMessages);
-        setLoadedMessages(messages);
-        setIsLoadingMessages(false);
-      }
-    },
-    [
-      loader,
-      config.fallbackLocales,
-      config.cache,
-      config.id,
-      setIsLoadingMessages,
-      namespaces,
-      staticMessages,
-      setLoadedMessages
-    ]
-  );
-  return { refetchMessages };
-};
-var MessagesContext = React7.createContext(void 0);
-function MessagesProvider({
-  value: { messages = {} },
-  children
-}) {
-  const { config, pathname } = useConfig();
-  const [loadedMessages, setLoadedMessages] = React7.useState(null);
-  const [isLoadingMessages, setIsLoadingMessages] = React7.useState(false);
-  const { refetchMessages } = useRefetchMessages({
-    config,
-    pathname,
-    setLoadedMessages,
-    setIsLoadingMessages
-  });
-  const value = React7.useMemo(
-    () => ({
-      messages: loadedMessages || messages,
-      isLoading: isLoadingMessages,
-      setLoadedMessages,
-      setIsLoadingMessages,
-      refetchMessages
-    }),
-    [loadedMessages, messages, isLoadingMessages, refetchMessages]
-  );
-  return /* @__PURE__ */ jsx(MessagesContext.Provider, { value, children });
-}
-function useMessages() {
-  const context = React7.useContext(MessagesContext);
-  if (!context)
-    throw new Error("useMessages must be used within a MessagesProvider");
-  return context;
-}
-var LocaleContext = React7.createContext(void 0);
-
-// src/client/react/contexts/locale/utils/change-locale.ts
-var changeLocale = ({
-  currentLocale,
-  newLocale,
-  loader,
-  cookie,
-  setLocale,
-  refetchMessages
-}) => {
-  if (typeof document === "undefined") return;
-  const { type } = loader || {};
-  if (newLocale === currentLocale) return;
-  if (type === "local") {
-    console.warn(
-      `[Intor] You are using "loader type: local" 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 (type === "remote" && refetchMessages) {
-    void refetchMessages(newLocale);
-  }
-};
-function LocaleProvider({
-  value: { initialLocale, onLocaleChange },
-  children
-}) {
-  const { config } = useConfig();
-  const { refetchMessages } = useMessages();
-  const { loader, cookie } = config;
-  const [currentLocale, setCurrentLocale] = React7.useState(initialLocale);
-  useInitLocaleCookie({ config, locale: initialLocale });
-  const setLocale = React7.useCallback(
-    async (newLocale) => {
-      changeLocale({
-        currentLocale,
-        newLocale,
-        loader,
-        cookie,
-        setLocale: setCurrentLocale,
-        refetchMessages
-      });
-      onLocaleChange?.(newLocale);
-    },
-    [currentLocale, loader, cookie, refetchMessages, onLocaleChange]
-  );
-  const value = React7.useMemo(
-    () => ({
-      locale: currentLocale,
-      setLocale
-    }),
-    [currentLocale, setLocale]
-  );
-  return /* @__PURE__ */ jsx(LocaleContext.Provider, { value, children });
-}
-function useLocale() {
-  const context = React7.useContext(LocaleContext);
-  if (!context)
-    throw new Error("useLocale must be used within a LocaleProvider");
-  return context;
-}
-
-// src/adapters/next/navigation/use-pathname.ts
-var usePathname = () => {
-  const { config } = useConfig();
-  const { locale } = useLocale();
-  const rawPathname = usePathname$1();
-  const { localePrefixedPathname, standardizedPathname, unprefixedPathname } = localizePathname({
-    config,
-    pathname: rawPathname,
-    locale
-  });
-  return {
-    localizedPathname: localePrefixedPathname,
-    standardizedPathname,
-    unprefixedPathname
-  };
-};
-
-// src/adapters/next/navigation/utils/should-full-reload.ts
-var shouldFullReload = ({
-  config,
-  targetPathname,
-  locale,
-  currentLocale
-}) => {
-  const loader = config.loader;
-  if (!loader || !loader.type) return false;
-  if (loader.type === "remote" && !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 { localizedPathname } = usePathname();
-  const resolveHref = ({
-    href,
-    locale
-  }) => {
-    const isLocaleValid = locale && config.supportedLocales?.includes(locale);
-    const targetLocale = isLocaleValid ? locale : currentLocale;
-    const targetPathname = href ?? localizedPathname;
-    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 });
-      globalThis.location.href = resolvedHref;
-      return;
-    } else {
-      setLocale(targetLocale);
-    }
-    return resolvedHref;
-  };
-  return { resolveHref, switchLocale };
-};
-var Link = ({
-  href,
-  locale,
-  children,
-  onClick,
-  ...props
-}) => {
-  const formatted = typeof href === "string" ? href : href ? 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__ */ jsx(NextLink, { href: resolvedHref, onClick: handleClick, ...props, children });
-};
-var useRouter = () => {
-  const { push, replace, ...rest } = useRouter$1();
-  const { switchLocale } = useLocaleSwitch();
-  const pushWithLocale = (href, options) => {
-    const resolvedHref = switchLocale({ href, locale: options?.locale });
-    if (resolvedHref) push(resolvedHref, options);
-  };
-  const replaceWithLocale = (href, options) => {
-    const resolvedHref = switchLocale({ href, locale: options?.locale });
-    if (resolvedHref) replace(resolvedHref, options);
-  };
-  return {
-    push: pushWithLocale,
-    replace: replaceWithLocale,
-    ...rest
-  };
-};
-
-// 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 cookies();
-  const headersStore = await headers();
-  const { defaultLocale, supportedLocales = [], cookie, routing } = config;
-  let locale;
-  if (cookie.enabled) {
-    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")) {
-    redirect$1(url);
-  }
-  const isLocaleValid = locale && config.supportedLocales?.includes(locale);
-  const { locale: detectedLocale } = await getI18nContext(config);
-  const { localePrefixedPathname } = localizePathname({
-    config,
-    pathname: url,
-    locale: isLocaleValid ? locale : detectedLocale
-  });
-  redirect$1(localePrefixedPathname, type);
-};
-var TranslateHandlersContext = React7.createContext(void 0);
-var TranslateHandlersProvider = ({
-  handlers,
-  children
-}) => {
-  return /* @__PURE__ */ jsx(TranslateHandlersContext.Provider, { value: { handlers }, children });
-};
-function useTranslateHandlers() {
-  const context = React7.useContext(TranslateHandlersContext);
-  return context;
-}
-var TranslatorContext = React7.createContext(void 0);
-function TranslatorProvider({
-  value: { isLoading: externalIsLoading },
-  children
-}) {
-  const { config } = useConfig();
-  const { messages, isLoading: internalIsLoading } = useMessages();
-  const { locale } = useLocale();
-  const { handlers } = useTranslateHandlers();
-  const { fallbackLocales, translator: translatorOptions } = config;
-  const isLoading = Boolean(externalIsLoading ?? internalIsLoading);
-  const translator = React7.useMemo(() => {
-    return new Translator({
-      messages,
-      locale,
-      isLoading,
-      fallbackLocales,
-      loadingMessage: translatorOptions?.loadingMessage,
-      placeholder: translatorOptions?.placeholder,
-      handlers
-    });
-  }, [
-    messages,
-    locale,
-    isLoading,
-    fallbackLocales,
-    handlers,
-    translatorOptions?.loadingMessage,
-    translatorOptions?.placeholder
-  ]);
-  return /* @__PURE__ */ jsx(TranslatorContext.Provider, { value: { translator }, children });
-}
-function useTranslator() {
-  const context = React7.useContext(TranslatorContext);
-  if (!context)
-    throw new Error(
-      "useTranslator must be used within IntorTranslatorProvider"
-    );
-  return context;
-}
-var IntorProvider = ({
-  value: {
-    config,
-    pathname = "",
-    initialLocale,
-    messages = config.messages,
-    onLocaleChange,
-    isLoading
-  },
-  children
-}) => {
-  return /* @__PURE__ */ jsx(ConfigProvider, { value: { config, pathname }, children: /* @__PURE__ */ jsx(MessagesProvider, { value: { messages }, children: /* @__PURE__ */ jsx(LocaleProvider, { value: { initialLocale, onLocaleChange }, children: /* @__PURE__ */ jsx(TranslatorProvider, { value: { isLoading }, children }) }) }) });
-};
-
-// src/client/react/hooks/use-translator.ts
-function useTranslator2(preKey) {
-  const { translator } = useTranslator();
-  const { setLocale } = useLocale();
-  const props = {
-    messages: translator.messages,
-    locale: translator.locale,
-    isLoading: translator.isLoading,
-    setLocale
-  };
-  const scoped = translator.scoped(preKey);
-  return {
-    ...props,
-    hasKey: preKey ? scoped.hasKey : translator.hasKey,
-    t: preKey ? scoped.t : translator.t
-  };
-}
-
-export { IntorProvider, Link, TranslateHandlersProvider, redirect, usePathname, useRouter, useTranslator2 as useTranslator };