intor 1.0.39 → 2.0.0

package/dist/next/index.cjs

@@ -2,9 +2,11 @@
 
 var React7 = require('react');
 var logry = require('logry');
+var Keyv = require('keyv');
 var intorTranslator = require('intor-translator');
 var NextLink = require('next/link');
 var navigation = require('next/navigation');
+var formatUrl = require('next/dist/shared/lib/router/utils/format-url');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -27,33 +29,26 @@ function _interopNamespace(e) {
 }
 
 var React7__namespace = /*#__PURE__*/_interopNamespace(React7);
+var Keyv__default = /*#__PURE__*/_interopDefault(Keyv);
 var NextLink__default = /*#__PURE__*/_interopDefault(NextLink);
 
-// src/adapters/next-client/contexts/intor-config/intor-config-context.ts
-var IntorConfigContext = React7__namespace.createContext(void 0);
-var IntorConfigProvider = ({
+// src/adapters/next/contexts/intor-provider/intor-provider.tsx
+var ConfigContext = React7__namespace.createContext(void 0);
+function ConfigProvider({
   value: { config, pathname },
   children
-}) => {
-  const value = React7__namespace.useMemo(
-    () => ({
-      config,
-      pathname
-    }),
-    [config, pathname]
-  );
-  return /* @__PURE__ */ React7__namespace.createElement(IntorConfigContext.Provider, { value }, children);
-};
-var useIntorConfig = () => {
-  const context = React7__namespace.useContext(IntorConfigContext);
-  if (!context) {
-    throw new Error("useIntorConfig must be used within IntorConfigProvider");
-  }
+}) {
+  const value = React7__namespace.useMemo(() => ({ config, pathname }), [config, pathname]);
+  return /* @__PURE__ */ React7__namespace.createElement(ConfigContext.Provider, { value }, children);
+}
+function useConfig() {
+  const context = React7__namespace.useContext(ConfigContext);
+  if (!context) throw new Error("useConfig must be used within ConfigProvider");
   return context;
-};
-var IntorLocaleContext = React7__namespace.createContext(void 0);
+}
+var LocaleContext = React7__namespace.createContext(void 0);
 
-// src/adapters/next-client/utils/build-cookie-string.ts
+// src/adapters/next/shared/utils/build-cookie-string.ts
 var buildCookieString = (cookie, locale) => {
   const parts = [];
   parts.push(`${cookie.name}=${encodeURIComponent(locale)}`);
@@ -77,22 +72,18 @@ var buildCookieString = (cookie, locale) => {
   return parts.join("; ");
 };
 
-// src/adapters/next-client/utils/set-locale-cookie-client.ts
-var setLocaleCookieClient = ({
+// 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;
-  }
+  if (typeof window === "undefined") return;
+  if (cookie.disabled || !cookie.autoSetCookie) return;
   const cookieString = buildCookieString(cookie, locale);
   document.cookie = cookieString;
 };
 
-// src/adapters/next-client/contexts/intor-locale/utils/change-locale.ts
+// src/adapters/next/contexts/locale/utils/change-locale.ts
 var changeLocale = ({
   currentLocale,
   newLocale,
@@ -101,32 +92,153 @@ var changeLocale = ({
   setLocale,
   refetchMessages
 }) => {
-  if (typeof document === "undefined") {
-    return;
-  }
+  if (typeof document === "undefined") return;
   const loaderType = loaderOptions?.type;
-  if (newLocale === currentLocale) {
-    return;
-  }
+  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);
-  setLocaleCookieClient({ cookie, locale: newLocale });
+  setLocaleCookieBrowser({ cookie, locale: newLocale });
   document.documentElement.lang = newLocale;
   if (loaderType === "api" && refetchMessages) {
     void refetchMessages(newLocale);
   }
 };
-var IntorMessagesContext = React7__namespace.createContext(void 0);
+var MessagesContext = React7__namespace.createContext(void 0);
+
+// src/modules/config/constants/cache.constants.ts
+var DEFAULT_CACHE_OPTIONS = {
+  enabled: process.env.NODE_ENV === "production",
+  ttl: 60 * 60 * 1e3
+  // 1 hour
+};
+
+// src/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/shared/logger/get-logger.ts
+var DEFAULT_FORMATTER_CONFIG = {
+  node: { meta: { compact: true }, lineBreaksAfter: 1 }
+};
+function getLogger({
+  id,
+  formatterConfig = DEFAULT_FORMATTER_CONFIG,
+  ...options
+}) {
+  const pool = getGlobalLoggerPool();
+  let logger = pool.get(id);
+  if (!logger) {
+    logger = logry.logry({ id, formatterConfig, ...options });
+    pool.set(id, logger);
+    if (pool.size > 1e3) {
+      const keys = Array.from(pool.keys());
+      for (const key of keys.slice(0, 200)) pool.delete(key);
+    }
+  }
+  return logger;
+}
+function getGlobalMessagesPool() {
+  if (!globalThis.__INTOR_MESSAGES_POOL__) {
+    globalThis.__INTOR_MESSAGES_POOL__ = new Keyv__default.default();
+  }
+  return globalThis.__INTOR_MESSAGES_POOL__;
+}
+
+// src/shared/utils/merge-messages.ts
+var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
+  const result = Object.keys(staticMessages).length ? { ...staticMessages } : {};
+  for (const locale in loadedMessages) {
+    const loaded = loadedMessages[locale];
+    if (!result[locale]) {
+      result[locale] = loaded;
+      continue;
+    }
+    result[locale] = {
+      ...result[locale],
+      ...loaded
+    };
+  }
+  return result;
+};
+
+// 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) 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/constants/prefix-placeholder.ts
+var PREFIX_PLACEHOLDER = "{locale}";
+
+// src/shared/utils/resolve-namespaces.ts
+var resolveNamespaces = ({
+  config,
+  pathname
+}) => {
+  const { loader } = config;
+  const {
+    routeNamespaces = {},
+    namespaces: fallbackNamespaces
+  } = loader;
+  const { unprefixedPathname } = extractPathname({ config, pathname });
+  const standardizedPathname = standardizePathname({
+    config,
+    pathname: unprefixedPathname
+  });
+  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 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];
+      }
+    }
+  }
+  const matchedNamespaces = bestNamespaces ?? routeNamespaces["/*"] ?? fallbackNamespaces ?? [];
+  if (matchedNamespaces.length > 0) {
+    return [...defaultNamespaces, ...matchedNamespaces];
+  } else {
+    return [...defaultNamespaces];
+  }
+};
 
 // src/shared/utils/pathname/normalize-pathname.ts
 var normalizePathname = (rawPathname, options = {}) => {
-  if (typeof rawPathname !== "string") {
-    throw new TypeError("Expected rawPathname to be a string");
-  }
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
@@ -156,300 +268,245 @@ var normalizePathname = (rawPathname, options = {}) => {
   return result || "/";
 };
 
-// src/modules/intor-messages-loader/fetch-api-messages/build-search-params.ts
-var buildSearchParams = (params) => {
-  const searchParams = new URLSearchParams();
-  const appendParam = (key, value) => {
-    if (value === void 0 || value === null) {
-      return;
+// 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 pathParts = prefixedPathname.split("/").filter(Boolean);
+  const maybeLocale = pathParts[0] || "";
+  const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
+  let unprefixedPathname = prefixedPathname;
+  if (prefix === "all") {
+    if (isLocalePrefixed) {
+      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
     }
-    if (Array.isArray(value) && value.length > 0) {
-      value.forEach((v) => v && searchParams.append(key, v));
-    } else {
-      searchParams.append(key, value);
+  } else if (prefix === "except-default") {
+    if (maybeLocale && maybeLocale !== defaultLocale && isLocalePrefixed) {
+      unprefixedPathname = prefixedPathname.slice(maybeLocale.length + 1) || "/";
     }
+  }
+  return {
+    basePath,
+    prefixedPathname,
+    unprefixedPathname,
+    maybeLocale,
+    isLocalePrefixed: Boolean(isLocalePrefixed)
   };
-  Object.entries(params).forEach(([key, value]) => {
-    appendParam(key, value);
-  });
-  return searchParams;
 };
-var fetcher = async ({
+
+// 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("/").replace(/\/{2,}/g, "/");
+  return normalizePathname(standardizedPathname);
+};
+
+// src/modules/messages/load-api-messages/fetch-messages.ts
+var fetchMessages = async ({
   apiUrl,
+  apiHeaders,
   locale,
   searchParams,
-  loggerId
+  logger: loggerOptions = { id: "default" }
 }) => {
-  const logger = logry.logry({ id: loggerId, scope: "fetcher" });
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "fetch-messages" });
   try {
     const params = new URLSearchParams(searchParams);
     params.append("locale", locale);
     const url = `${apiUrl}?${params.toString()}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...apiHeaders
+    };
     const response = await fetch(url, {
       method: "GET",
-      headers: { "Content-Type": "application/json" },
+      headers,
       cache: "no-store"
     });
     if (!response.ok) {
-      throw new Error(
-        `Fetch failed for locale "${locale}" at URL: ${url} - ${response.status} ${response.statusText}`
-      );
+      throw new Error(`Fetch failed: ${locale} (${response.status})`);
     }
     const data = await response.json();
     if (data == null || typeof data === "object" && Object.keys(data).length === 0) {
-      throw new Error(
-        `Missing or invalid messages for locale "${locale}" at URL: ${url}`
-      );
+      throw new Error(`Invalid messages: ${locale}`);
     }
     return data;
-  } catch {
+  } catch (error) {
     logger.warn(`Failed to fetch messages for locale "${locale}".`, {
       locale,
       apiUrl,
-      searchParams: decodeURIComponent(searchParams.toString())
+      searchParams: decodeURIComponent(searchParams.toString()),
+      error
     });
-    return void 0;
+    return;
   }
 };
 
-// src/modules/intor-messages-loader/fetch-api-messages/fetch-fallback-messages.ts
-var fetchFallbackMessages = async (apiUrl, searchParams, fallbackLocales, loggerId) => {
+// src/modules/messages/load-api-messages/fetch-fallback-messages.ts
+var fetchFallbackMessages = async ({
+  apiUrl,
+  apiHeaders,
+  searchParams,
+  fallbackLocales,
+  logger
+}) => {
   for (const fallbackLocale of fallbackLocales) {
-    const result = await fetcher({
+    const result = await fetchMessages({
       apiUrl,
       searchParams,
       locale: fallbackLocale,
-      loggerId
+      apiHeaders,
+      logger
     });
     if (result) {
       return { locale: fallbackLocale, messages: result };
     }
   }
-  return void 0;
+  return;
 };
 
-// src/modules/intor-messages-loader/fetch-api-messages/fetch-api-messages.ts
-var fetchApiMessages = async ({
+// src/modules/messages/load-api-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/modules/messages/load-api-messages/load-api-messages.ts
+var loadApiMessages = async ({
   apiUrl,
+  apiHeaders,
   basePath,
   locale,
   fallbackLocales = [],
   namespaces = [],
-  loggerId
+  cache = DEFAULT_CACHE_OPTIONS,
+  logger: loggerOptions = { id: "default" }
 }) => {
-  const logger = logry.logry({ id: loggerId, scope: "fetchApiMessages" });
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "load-api-messages" });
   if (!apiUrl) {
-    logger.warn("No apiUrl provided for fetchApiMessages. Skipping fetch.");
-    return void 0;
+    logger.warn("No apiUrl provided. Skipping fetch.");
+    return;
   }
-  const searchParams = buildSearchParams({
+  const pool = getGlobalMessagesPool();
+  const key = normalizeCacheKey([
+    loggerOptions.id,
     basePath,
-    loggerId,
-    namespaces
-  });
-  const messages = await fetcher({
+    locale,
+    [...fallbackLocales ?? []].sort().join(","),
+    [...namespaces ?? []].sort().join(",")
+  ]);
+  if (cache.enabled && key) {
+    const cached = await pool.get(key);
+    if (cached) {
+      logger.debug("Messages cache hit.", { key });
+      return cached;
+    }
+  }
+  const searchParams = buildSearchParams({ basePath, namespaces });
+  const messages = await fetchMessages({
     apiUrl,
+    apiHeaders,
     searchParams,
     locale,
-    loggerId
+    logger: loggerOptions
   });
   if (messages) {
+    if (cache.enabled && key) {
+      await pool.set(key, messages, cache.ttl);
+    }
     return messages;
   }
-  const fallbackResult = await fetchFallbackMessages(
+  const fallbackResult = await fetchFallbackMessages({
     apiUrl,
+    apiHeaders,
     searchParams,
     fallbackLocales,
-    loggerId
-  );
+    logger: loggerOptions
+  });
   if (fallbackResult) {
     logger.info("Fallback locale succeeded.", {
       usedLocale: fallbackResult.locale,
       apiUrl,
       searchParams: decodeURIComponent(searchParams.toString())
     });
+    if (cache.enabled && key) {
+      await pool.set(key, fallbackResult.messages, cache.ttl);
+    }
     return fallbackResult.messages;
   }
   logger.warn("Failed to fetch messages for all locales.", {
     locale,
     fallbackLocales
   });
-  return void 0;
-};
-
-// 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 pathParts = prefixedPathname.split("/").filter(Boolean);
-  const maybeLocale = pathParts[0] || "";
-  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, prefixPlaceHolder } = config;
-  const { basePath } = routing;
-  const parts = [
-    normalizePathname(basePath),
-    normalizePathname(prefixPlaceHolder),
-    normalizePathname(pathname)
-  ];
-  const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
-  return normalizePathname(standardizedPathname);
-};
-
-// src/shared/utils/resolve-namespaces.ts
-var resolveNamespaces = ({
-  config,
-  pathname
-}) => {
-  const { loaderOptions, prefixPlaceHolder } = config;
-  const {
-    routeNamespaces = {},
-    namespaces: fallbackNamespaces
-  } = loaderOptions;
-  const { unprefixedPathname } = extractPathname({ config, pathname });
-  const standardizedPathname = standardizePathname({
-    config,
-    pathname: unprefixedPathname
-  });
-  const placeholderRemovedPathname = standardizedPathname.replace(
-    `/${prefixPlaceHolder}`,
-    ""
-  );
-  const defaultNamespaces = routeNamespaces.default ?? [];
-  const exactMatchNamespaces = routeNamespaces[standardizedPathname] ?? routeNamespaces[placeholderRemovedPathname];
-  if (exactMatchNamespaces) {
-    return [...defaultNamespaces, ...exactMatchNamespaces];
-  }
-  let bestMatch = "";
-  let bestNamespaces;
-  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];
-      }
-    }
-  }
-  const matchedNamespaces = bestNamespaces ?? routeNamespaces["/*"] ?? fallbackNamespaces ?? [];
-  if (matchedNamespaces.length > 0) {
-    return [...defaultNamespaces, ...matchedNamespaces];
-  } else {
-    return [...defaultNamespaces];
-  }
+  return;
 };
 
-// src/adapters/next-client/hooks/api/use-fetch-messages.ts
-var useFetchMessages = ({
-  onError
-}) => {
-  const fetcher2 = async (params) => {
-    try {
-      const data = await fetchApiMessages(params);
-      return data;
-    } catch (error) {
-      onError?.(error, params.apiUrl);
-      return null;
-    }
-  };
-  return { fetcher: fetcher2 };
-};
-
-// src/shared/utils/merge-static-and-dynamic-messages.ts
-var mergeStaticAndDynamicMessages = (staticMessages = {}, dynamicMessages = {}) => {
-  const result = Object.keys(staticMessages).length ? { ...staticMessages } : {};
-  for (const locale in dynamicMessages) {
-    const dynamic = dynamicMessages[locale];
-    if (!result[locale]) {
-      result[locale] = dynamic;
-      continue;
-    }
-    result[locale] = {
-      ...result[locale],
-      ...dynamic
-    };
-  }
-  return result;
-};
-
-// src/adapters/next-client/hooks/api/use-refetch-messages.ts
+// src/adapters/next/contexts/messages/utils/use-refetch-messages.ts
 var useRefetchMessages = ({
   config,
   pathname,
   setLoadedMessages,
-  setIsLoadingMessages,
-  onError
-  // Error handler
+  setIsLoadingMessages
 }) => {
   const { messages: staticMessages } = config;
   const namespaces = React7__namespace.useMemo(() => {
-    if (!config.loaderOptions) {
-      return [];
-    }
+    if (!config.loader) return [];
     return resolveNamespaces({ config, pathname });
   }, [config, pathname]);
-  const { fetcher: fetcher2 } = useFetchMessages({ onError });
   const refetchMessages = React7__namespace.useCallback(
     async (newLocale) => {
-      if (config.loaderOptions?.type === "api") {
+      if (config.loader?.type === "api") {
         setIsLoadingMessages(true);
-        const dynamicMessages = await fetcher2({
-          ...config.loaderOptions,
+        const loadedMessages = await loadApiMessages({
+          ...config.loader,
           locale: newLocale,
           fallbackLocales: config.fallbackLocales[newLocale] || [],
           namespaces,
-          loggerId: config.id
+          logger: { id: config.id }
         });
-        const messages = mergeStaticAndDynamicMessages(
-          staticMessages,
-          dynamicMessages
-        );
+        const messages = mergeMessages(staticMessages, loadedMessages);
         setLoadedMessages(messages);
         setIsLoadingMessages(false);
       }
     },
     [
-      config.loaderOptions,
+      config.loader,
       config.fallbackLocales,
       config.id,
       setIsLoadingMessages,
-      fetcher2,
       namespaces,
       staticMessages,
       setLoadedMessages
@@ -458,12 +515,12 @@ var useRefetchMessages = ({
   return { refetchMessages };
 };
 
-// src/adapters/next-client/contexts/intor-messages/intor-messages-provider.tsx
-var IntorMessagesProvider = ({
+// src/adapters/next/contexts/messages/provider.tsx
+function MessagesProvider({
   value: { messages },
   children
-}) => {
-  const { config, pathname } = useIntorConfig();
+}) {
+  const { config, pathname } = useConfig();
   const [loadedMessages, setLoadedMessages] = React7__namespace.useState(null);
   const [isLoadingMessages, setIsLoadingMessages] = React7__namespace.useState(false);
   const { refetchMessages } = useRefetchMessages({
@@ -482,22 +539,19 @@ var IntorMessagesProvider = ({
     }),
     [loadedMessages, messages, isLoadingMessages, refetchMessages]
   );
-  return /* @__PURE__ */ React7__namespace.createElement(IntorMessagesContext.Provider, { value }, children);
-};
-var useIntorMessages = () => {
-  const context = React7__namespace.useContext(IntorMessagesContext);
-  if (!context) {
-    throw new Error(
-      "useIntorMessages must be used within a IntorMessagesProvider"
-    );
-  }
+  return /* @__PURE__ */ React7__namespace.createElement(MessagesContext.Provider, { value }, children);
+}
+function useMessages() {
+  const context = React7__namespace.useContext(MessagesContext);
+  if (!context)
+    throw new Error("useMessages must be used within a MessagesProvider");
   return context;
-};
+}
 var useInitLazyLoad = ({
   loaderOptions,
   currentLocale
 }) => {
-  const { refetchMessages } = useIntorMessages();
+  const { refetchMessages } = useMessages();
   const lazyLoad = !!loaderOptions?.lazyLoad;
   const isFirstLoadedRef = React7__namespace.useRef(false);
   React7__namespace.useEffect(() => {
@@ -512,34 +566,26 @@ var useInitLocaleCookie = ({
   locale
 }) => {
   React7__namespace.useEffect(() => {
-    if (typeof document === "undefined") {
-      return;
-    }
+    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}=`));
-    if (isCookieExists) {
-      return;
-    }
-    if (!firstVisit.redirect) {
-      return;
-    }
-    if (cookie.disabled || !cookie.autoSetCookie) {
-      return;
-    }
-    setLocaleCookieClient({ cookie, locale });
+    if (isCookieExists) return;
+    if (!firstVisit.redirect) return;
+    if (cookie.disabled || !cookie.autoSetCookie) return;
+    setLocaleCookieBrowser({ cookie, locale });
   }, []);
 };
 
-// src/adapters/next-client/contexts/intor-locale/intor-locale-provider.tsx
-var IntorLocaleProvider = ({
+// src/adapters/next/contexts/locale/provider.tsx
+function LocaleProvider({
   value: { initialLocale },
   children
-}) => {
-  const { config } = useIntorConfig();
-  const { refetchMessages } = useIntorMessages();
-  const { loaderOptions, cookie } = config;
+}) {
+  const { config } = useConfig();
+  const { refetchMessages } = useMessages();
+  const { loader: loaderOptions, cookie } = config;
   const [currentLocale, setCurrentLocale] = React7__namespace.useState(initialLocale);
   useInitLazyLoad({ loaderOptions, currentLocale });
   useInitLocaleCookie({ config, locale: initialLocale });
@@ -563,23 +609,33 @@ var IntorLocaleProvider = ({
     }),
     [currentLocale, setLocale]
   );
-  return /* @__PURE__ */ React7__namespace.createElement(IntorLocaleContext.Provider, { value }, children);
-};
-var useIntorLocale = () => {
-  const context = React7__namespace.useContext(IntorLocaleContext);
-  if (!context) {
-    throw new Error("useIntorLocale must be used within a IntorLocaleProvider");
-  }
+  return /* @__PURE__ */ React7__namespace.createElement(LocaleContext.Provider, { value }, children);
+}
+function useLocale() {
+  const context = React7__namespace.useContext(LocaleContext);
+  if (!context)
+    throw new Error("useLocale must be used within a LocaleProvider");
   return context;
-};
-var IntorTranslatorContext = React7__namespace.createContext(void 0);
+}
+var TranslatorContext = React7__namespace.createContext(void 0);
 var TranslateHandlersContext = React7__namespace.createContext(void 0);
-var useTranslateHandlers = () => {
+var TranslateHandlersProvider = ({
+  children,
+  handlers
+}) => {
+  const value = handlers;
+  return /* @__PURE__ */ React7__namespace.createElement(TranslateHandlersContext.Provider, { value }, children);
+};
+function useTranslateHandlers() {
   const context = React7__namespace.useContext(TranslateHandlersContext);
+  if (!context)
+    throw new Error(
+      "useTranslateHandlers must be used within a TranslateHandlersProvider"
+    );
   return context;
-};
+}
 var useInitLoadingState = (config) => {
-  const lazyLoad = !!config.loaderOptions?.lazyLoad;
+  const lazyLoad = !!config.loader?.lazyLoad;
   const [isCsr, setIsCsr] = React7__namespace.useState(false);
   React7__namespace.useEffect(() => {
     setIsCsr(true);
@@ -588,14 +644,12 @@ var useInitLoadingState = (config) => {
   return isBeforeCSRLoading;
 };
 
-// src/adapters/next-client/contexts/intor-translator/intor-translator-provider.tsx
+// src/adapters/next/contexts/translator/provider.tsx
 var EMPTY_OBJECT = Object.freeze({});
-var IntorTranslatorProvider = ({
-  children
-}) => {
-  const { config } = useIntorConfig();
-  const { messages, isLoading } = useIntorMessages();
-  const { locale } = useIntorLocale();
+function TranslatorProvider({ children }) {
+  const { config } = useConfig();
+  const { messages, isLoading } = useMessages();
+  const { locale } = useLocale();
   const translatorHandlers = useTranslateHandlers();
   const { fallbackLocales, translator: translatorOptions } = config;
   const isBeforeCSRLoading = useInitLoadingState(config);
@@ -620,79 +674,69 @@ var IntorTranslatorProvider = ({
     translatorOptions?.loadingMessage,
     translatorOptions?.placeholder
   ]);
-  return /* @__PURE__ */ React7__namespace.createElement(IntorTranslatorContext.Provider, { value }, children);
-};
-function useIntorTranslator() {
-  const context = React7__namespace.useContext(IntorTranslatorContext);
-  if (!context) {
+  return /* @__PURE__ */ React7__namespace.createElement(TranslatorContext.Provider, { value }, children);
+}
+function useTranslator() {
+  const context = React7__namespace.useContext(TranslatorContext);
+  if (!context)
     throw new Error(
       "useIntorTranslator must be used within IntorTranslatorProvider"
     );
-  }
   return context;
 }
 
-// src/adapters/next-client/hooks/use-intor/use-intor.ts
-function useIntorWithPreKey(preKey) {
-  const { translator } = useIntorTranslator();
-  const { setLocale } = useIntorLocale();
-  const scoped = translator.scoped(
-    preKey
-  );
-  return {
-    messages: translator.messages,
-    locale: translator.locale,
-    isLoading: translator.isLoading,
-    setLocale,
-    hasKey: scoped.hasKey,
-    t: scoped.t
-  };
-}
-function useIntorWithoutPreKey() {
-  const { translator } = useIntorTranslator();
-  const { setLocale } = useIntorLocale();
-  const scoped = translator.scoped();
-  return {
+// src/adapters/next/contexts/intor-provider/intor-provider.tsx
+var IntorProvider = ({
+  value: { config, pathname, initialLocale, messages },
+  children
+}) => {
+  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) {
+  const { translator } = useTranslator();
+  const { setLocale } = useLocale();
+  const sharedMethod = {
     messages: translator.messages,
     locale: translator.locale,
     isLoading: translator.isLoading,
-    setLocale,
-    hasKey: scoped.hasKey,
-    t: scoped.t
+    setLocale
   };
-}
-function useIntor(preKey) {
   if (preKey) {
-    return useIntorWithPreKey(preKey);
+    const { hasKey, t } = translator.scoped(preKey);
+    return { ...sharedMethod, hasKey, t };
+  } else {
+    const { hasKey, t } = translator;
+    return { ...sharedMethod, hasKey, t };
   }
-  return useIntorWithoutPreKey();
 }
 
-// src/adapters/next-client/utils/locale-prefix-pathname.ts
+// src/adapters/next/shared/utils/locale-prefix-pathname.ts
 var localePrefixPathname = ({
   config,
   pathname: standardizedPathname,
   locale
 }) => {
-  const { routing, prefixPlaceHolder } = config;
+  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 standardizedPathname.replace(prefixPlaceHolder, locale);
+    return standardizedPathname.replace(PREFIX_PLACEHOLDER, locale);
   }
   if (prefix === "except-default") {
     if (locale === config.defaultLocale) {
-      return standardizedPathname.replace(`/${prefixPlaceHolder}`, "");
+      return standardizedPathname.replace(`/${PREFIX_PLACEHOLDER}`, "");
     } else {
-      return standardizedPathname.replace(prefixPlaceHolder, locale);
+      return standardizedPathname.replace(PREFIX_PLACEHOLDER, locale);
     }
   }
-  return standardizedPathname.replace(`/${prefixPlaceHolder}`, "");
+  return standardizedPathname.replace(`/${PREFIX_PLACEHOLDER}`, "");
 };
 
-// src/adapters/next-client/utils/localize-pathname.ts
+// src/adapters/next/shared/utils/localize-pathname.ts
 var localizePathname = ({
   config,
   pathname: rawPathname,
@@ -718,13 +762,13 @@ var localizePathname = ({
   };
 };
 
-// src/adapters/next-client/utils/should-use-full-reload.ts
-var shouldUseFullReload = (loaderOptions) => {
+// src/adapters/next/tools/utils/should-full-reload.ts
+var shouldFullReload = (loaderOptions) => {
   return loaderOptions?.type === "import" || loaderOptions?.type === "api" && loaderOptions.fullReload === true;
 };
 var usePathname = () => {
-  const { config } = useIntorConfig();
-  const { locale } = useIntorLocale();
+  const { config } = useConfig();
+  const { locale } = useLocale();
   const rawPathname = navigation.usePathname();
   const { localePrefixedPathname } = localizePathname({
     config,
@@ -733,8 +777,6 @@ var usePathname = () => {
   });
   return localePrefixedPathname;
 };
-
-// src/adapters/next-client/tools/Link.tsx
 var Link = ({
   href,
   locale,
@@ -742,31 +784,32 @@ var Link = ({
   onClick,
   ...props
 }) => {
-  const { config } = useIntorConfig();
-  const { locale: currentLocale, setLocale } = useIntorLocale();
+  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: href ?? pathname,
+    pathname: formattedUrl ?? pathname,
     locale: targetLocale
   });
-  href = localePrefixedPathname;
+  const resolvedHref = localePrefixedPathname;
   const handleClick = (e) => {
     onClick?.(e);
-    if (shouldUseFullReload(config.loaderOptions)) {
-      setLocaleCookieClient({ cookie: config.cookie, locale: targetLocale });
-      window.location.href = href;
+    if (shouldFullReload(config.loader)) {
+      setLocaleCookieBrowser({ cookie: config.cookie, locale: targetLocale });
+      window.location.href = resolvedHref;
       return;
     } else {
       setLocale(targetLocale);
     }
   };
-  return /* @__PURE__ */ React7__namespace.createElement(NextLink__default.default, { href, onClick: handleClick, ...props }, children);
+  return /* @__PURE__ */ React7__namespace.createElement(NextLink__default.default, { href: resolvedHref, onClick: handleClick, ...props }, children);
 };
 var useRouter = () => {
-  const { config } = useIntorConfig();
-  const { locale: currentLocale, setLocale } = useIntorLocale();
+  const { config } = useConfig();
+  const { locale: currentLocale, setLocale } = useLocale();
   const { push, replace, ...rest } = navigation.useRouter();
   const pushWithLocale = (href, options) => {
     const targetLocale = options?.locale || currentLocale;
@@ -778,7 +821,7 @@ var useRouter = () => {
       });
       href = localePrefixedPathname;
     }
-    if (shouldUseFullReload(config.loaderOptions)) {
+    if (shouldFullReload(config.loader)) {
       window.location.href = href;
       return;
     } else {
@@ -796,7 +839,7 @@ var useRouter = () => {
       });
       href = localePrefixedPathname;
     }
-    if (shouldUseFullReload(config.loaderOptions)) {
+    if (shouldFullReload(config.loader)) {
       window.location.href = href;
       return;
     } else {
@@ -811,16 +854,13 @@ var useRouter = () => {
   };
 };
 
-exports.IntorConfigProvider = IntorConfigProvider;
-exports.IntorLocaleProvider = IntorLocaleProvider;
-exports.IntorMessagesProvider = IntorMessagesProvider;
-exports.IntorTranslatorProvider = IntorTranslatorProvider;
+// src/adapters/next/shared/constants/pathname-header-name.ts
+var PATHNAME_HEADER_NAME = "x-intor-pathname";
+
+exports.IntorProvider = IntorProvider;
 exports.Link = Link;
-exports.TranslateHandlersContext = TranslateHandlersContext;
+exports.PATHNAME_HEADER_NAME = PATHNAME_HEADER_NAME;
+exports.TranslateHandlersProvider = TranslateHandlersProvider;
 exports.useIntor = useIntor;
-exports.useIntorConfig = useIntorConfig;
-exports.useIntorLocale = useIntorLocale;
-exports.useIntorMessages = useIntorMessages;
-exports.useIntorTranslator = useIntorTranslator;
 exports.usePathname = usePathname;
 exports.useRouter = useRouter;