intor 1.0.16 → 1.0.18

package/dist/index.cjs

@@ -7,12 +7,18 @@ var perf_hooks = require('perf_hooks');
 var pLimit = require('p-limit');
 var fs = require('fs/promises');
 var intorTranslator = require('intor-translator');
+var React6 = require('react');
+var server = require('next/server');
+var NextLink = require('next/link');
+var navigation = require('next/navigation');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var path__default = /*#__PURE__*/_interopDefault(path);
 var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
+var React6__default = /*#__PURE__*/_interopDefault(React6);
+var NextLink__default = /*#__PURE__*/_interopDefault(NextLink);
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -33,6 +39,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var initializeLogger = ({
   id,
   scope,
@@ -1150,14 +1168,764 @@ var createIntor = (config, translateHandlers) => {
     return translator;
   };
 };
+var IntorConfigContext = React6.createContext(void 0);
+var IntorConfigProvider = ({
+  value: { config, pathname },
+  children
+}) => {
+  const value = React6.useMemo(
+    () => ({
+      config,
+      pathname
+    }),
+    [config, pathname]
+  );
+  return /* @__PURE__ */ React6__default.default.createElement(IntorConfigContext.Provider, { value }, children);
+};
+var useIntorConfig = () => {
+  const context = React6.useContext(IntorConfigContext);
+  if (!context) {
+    throw new Error("useIntorConfig must be used within IntorConfigProvider");
+  }
+  return context;
+};
+var IntorLocaleContext = React6.createContext(void 0);
+
+// src/adapters/next-client/utils/build-cookie-string.ts
+var buildCookieString = (cookie, locale) => {
+  var _a;
+  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=${(_a = cookie.path) != null ? _a : "/"}`);
+  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-client/utils/set-locale-cookie-client.ts
+var setLocaleCookieClient = ({
+  cookie,
+  locale
+}) => {
+  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
+var changeLocale = ({
+  currentLocale,
+  newLocale,
+  loaderOptions,
+  cookie,
+  setLocale,
+  refetchMessages
+}) => {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const loaderType = loaderOptions == null ? void 0 : 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);
+  setLocaleCookieClient({ cookie, locale: newLocale });
+  document.documentElement.lang = newLocale;
+  if (loaderType === "api" && refetchMessages) {
+    void refetchMessages(newLocale);
+  }
+};
+var IntorMessagesContext = React6.createContext(void 0);
+
+// 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 == null ? void 0 : onError(error, params.apiUrl);
+      return null;
+    }
+  };
+  return { fetcher: fetcher2 };
+};
+
+// src/adapters/next-client/hooks/api/use-refetch-messages.ts
+var useRefetchMessages = ({
+  config,
+  pathname,
+  setLoadedMessages,
+  setIsLoadingMessages,
+  onError
+  // Error handler
+}) => {
+  const { messages: staticMessages } = config;
+  const namespaces = React6.useMemo(() => {
+    if (!config.loaderOptions) {
+      return [];
+    }
+    return resolveNamespaces({ config, pathname });
+  }, [config, pathname]);
+  const { fetcher: fetcher2 } = useFetchMessages({ onError });
+  const refetchMessages = React6.useCallback(
+    async (newLocale) => {
+      var _a;
+      if (((_a = config.loaderOptions) == null ? void 0 : _a.type) === "api") {
+        setIsLoadingMessages(true);
+        const dynamicMessages = await fetcher2(__spreadProps(__spreadValues({}, config.loaderOptions), {
+          locale: newLocale,
+          fallbackLocales: config.fallbackLocales[newLocale] || [],
+          namespaces,
+          loggerId: config.id
+        }));
+        const messages = mergeStaticAndDynamicMessages(
+          staticMessages,
+          dynamicMessages
+        );
+        setLoadedMessages(messages);
+        setIsLoadingMessages(false);
+      }
+    },
+    [
+      config.loaderOptions,
+      config.fallbackLocales,
+      config.id,
+      setIsLoadingMessages,
+      fetcher2,
+      namespaces,
+      staticMessages,
+      setLoadedMessages
+    ]
+  );
+  return { refetchMessages };
+};
+
+// src/adapters/next-client/contexts/intor-messages/intor-messages-provider.tsx
+var IntorMessagesProvider = ({
+  value: { messages },
+  children
+}) => {
+  const { config, pathname } = useIntorConfig();
+  const [loadedMessages, setLoadedMessages] = React6.useState(null);
+  const [isLoadingMessages, setIsLoadingMessages] = React6.useState(false);
+  const { refetchMessages } = useRefetchMessages({
+    config,
+    pathname,
+    setLoadedMessages,
+    setIsLoadingMessages
+  });
+  const value = React6.useMemo(
+    () => ({
+      messages: loadedMessages || messages,
+      isLoading: isLoadingMessages,
+      setLoadedMessages,
+      setIsLoadingMessages,
+      refetchMessages
+    }),
+    [loadedMessages, messages, isLoadingMessages, refetchMessages]
+  );
+  return /* @__PURE__ */ React6__default.default.createElement(IntorMessagesContext.Provider, { value }, children);
+};
+var useIntorMessages = () => {
+  const context = React6.useContext(IntorMessagesContext);
+  if (!context) {
+    throw new Error(
+      "useIntorMessages must be used within a IntorMessagesProvider"
+    );
+  }
+  return context;
+};
+var useInitLazyLoad = ({
+  loaderOptions,
+  currentLocale
+}) => {
+  const { refetchMessages } = useIntorMessages();
+  const lazyLoad = !!(loaderOptions == null ? void 0 : loaderOptions.lazyLoad);
+  const isFirstLoadedRef = React6.useRef(false);
+  React6.useEffect(() => {
+    if (lazyLoad && !isFirstLoadedRef.current) {
+      void refetchMessages(currentLocale);
+      isFirstLoadedRef.current = true;
+    }
+  }, [lazyLoad, currentLocale, refetchMessages, isFirstLoadedRef]);
+};
+var useInitLocaleCookie = ({
+  config,
+  locale
+}) => {
+  React6.useEffect(() => {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const { cookie, routing } = config;
+    const { firstVisit } = routing;
+    const cookies3 = document.cookie.split(";").map((c) => c.trim());
+    const isCookieExists = cookies3.some((c) => c.startsWith(`${cookie.name}=`));
+    if (isCookieExists) {
+      return;
+    }
+    if (!firstVisit.redirect) {
+      return;
+    }
+    if (cookie.disabled || !cookie.autoSetCookie) {
+      return;
+    }
+    setLocaleCookieClient({ cookie, locale });
+  }, []);
+};
+
+// src/adapters/next-client/contexts/intor-locale/intor-locale-provider.tsx
+var IntorLocaleProvider = ({
+  value: { initialLocale },
+  children
+}) => {
+  const { config } = useIntorConfig();
+  const { refetchMessages } = useIntorMessages();
+  const { loaderOptions, cookie } = config;
+  const [currentLocale, setCurrentLocale] = React6.useState(initialLocale);
+  useInitLazyLoad({ loaderOptions, currentLocale });
+  useInitLocaleCookie({ config, locale: initialLocale });
+  const setLocale = React6.useCallback(
+    (newLocale) => {
+      changeLocale({
+        currentLocale,
+        newLocale,
+        loaderOptions,
+        cookie,
+        setLocale: setCurrentLocale,
+        refetchMessages
+      });
+    },
+    [currentLocale, loaderOptions, cookie, refetchMessages]
+  );
+  const value = React6.useMemo(
+    () => ({
+      locale: currentLocale,
+      setLocale
+    }),
+    [currentLocale, setLocale]
+  );
+  return /* @__PURE__ */ React6__default.default.createElement(IntorLocaleContext.Provider, { value }, children);
+};
+var useIntorLocale = () => {
+  const context = React6.useContext(IntorLocaleContext);
+  if (!context) {
+    throw new Error("useIntorLocale must be used within a IntorLocaleProvider");
+  }
+  return context;
+};
+var IntorTranslatorContext = React6.createContext(void 0);
+var TranslateHandlersContext = React6.createContext(void 0);
+var TranslateHandlersProvider = ({
+  children,
+  handlers
+}) => {
+  const value = handlers;
+  return /* @__PURE__ */ React6__default.default.createElement(TranslateHandlersContext.Provider, { value }, children);
+};
+var useTranslateHandlers = () => {
+  const context = React6.useContext(TranslateHandlersContext);
+  return context;
+};
+var useInitLoadingState = (config) => {
+  var _a;
+  const lazyLoad = !!((_a = config.loaderOptions) == null ? void 0 : _a.lazyLoad);
+  const [isCsr, setIsCsr] = React6.useState(false);
+  React6.useEffect(() => {
+    setIsCsr(true);
+  }, []);
+  const isBeforeCSRLoading = lazyLoad && !isCsr;
+  return isBeforeCSRLoading;
+};
+
+// src/adapters/next-client/contexts/intor-translator/intor-translator-provider.tsx
+var EMPTY_OBJECT = Object.freeze({});
+var IntorTranslatorProvider = ({
+  children
+}) => {
+  const { config } = useIntorConfig();
+  const { messages, isLoading } = useIntorMessages();
+  const { locale } = useIntorLocale();
+  const translatorHandlers = useTranslateHandlers();
+  const { fallbackLocales, translator: translatorOptions } = config;
+  const isBeforeCSRLoading = useInitLoadingState(config);
+  const value = React6.useMemo(() => {
+    const translator = new intorTranslator.Translator({
+      messages: messages || EMPTY_OBJECT,
+      locale,
+      fallbackLocales,
+      loadingMessage: translatorOptions == null ? void 0 : translatorOptions.loadingMessage,
+      placeholder: translatorOptions == null ? void 0 : translatorOptions.placeholder,
+      handlers: translatorHandlers
+    });
+    translator.setLoading(isBeforeCSRLoading || isLoading);
+    return { translator };
+  }, [
+    fallbackLocales,
+    isBeforeCSRLoading,
+    isLoading,
+    locale,
+    messages,
+    translatorHandlers,
+    translatorOptions == null ? void 0 : translatorOptions.loadingMessage,
+    translatorOptions == null ? void 0 : translatorOptions.placeholder
+  ]);
+  return /* @__PURE__ */ React6__default.default.createElement(IntorTranslatorContext.Provider, { value }, children);
+};
+function useIntorTranslator() {
+  const context = React6.useContext(IntorTranslatorContext);
+  if (!context) {
+    throw new Error(
+      "useIntorTranslator must be used within IntorTranslatorProvider"
+    );
+  }
+  return context;
+}
+var IntorProvider = ({
+  value: { config, pathname, initialLocale, messages },
+  children
+}) => {
+  return /* @__PURE__ */ React6__default.default.createElement(IntorConfigProvider, { value: { config, pathname } }, /* @__PURE__ */ React6__default.default.createElement(IntorMessagesProvider, { value: { messages } }, /* @__PURE__ */ React6__default.default.createElement(IntorLocaleProvider, { value: { initialLocale } }, /* @__PURE__ */ React6__default.default.createElement(IntorTranslatorProvider, null, children))));
+};
+
+// 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,
+    setLocale,
+    hasKey: scoped.hasKey,
+    t: scoped.t
+  };
+}
+function useIntorWithoutPreKey() {
+  const { translator } = useIntorTranslator();
+  const { setLocale } = useIntorLocale();
+  const scoped = translator.scoped();
+  return {
+    messages: translator.messages,
+    setLocale,
+    hasKey: scoped.hasKey,
+    t: scoped.t
+  };
+}
+function useIntor(preKey) {
+  if (preKey) {
+    return useIntorWithPreKey(preKey);
+  }
+  return useIntorWithoutPreKey();
+}
+
+// src/adapters/next-client/routing/utils/set-locale-cookie-edge.ts
+function setLocaleCookieEdge({
+  request,
+  response,
+  cookie,
+  locale,
+  override = false
+  // Default to not override existed cookie
+}) {
+  if (cookie.disabled || !cookie.autoSetCookie) {
+    return;
+  }
+  const isCookieExists = request.cookies.has(cookie.name);
+  if (isCookieExists && !override) {
+    return;
+  }
+  response.cookies.set(cookie.name, locale, __spreadProps(__spreadValues({
+    maxAge: cookie.maxAge,
+    path: cookie.path
+  }, cookie.domain ? { domain: cookie.domain } : {}), {
+    secure: cookie.secure,
+    httpOnly: cookie.httpOnly,
+    sameSite: cookie.sameSite
+  }));
+}
+
+// src/adapters/next-client/routing/utils/set-pathname-header.ts
+var setPathnameHeader = ({
+  request,
+  response,
+  key = DEFAULT_PATHNAME_HEADER_KEY
+}) => {
+  const pathname = request.nextUrl.pathname;
+  response.headers.set(key, pathname);
+  return response;
+};
+
+// src/adapters/next-client/utils/locale-prefix-pathname.ts
+var localePrefixPathname = ({
+  config,
+  pathname: standardizedPathname,
+  locale
+}) => {
+  const { routing, prefixPlaceHolder } = 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);
+  }
+  if (prefix === "except-default") {
+    if (locale === config.defaultLocale) {
+      return standardizedPathname.replace(`/${prefixPlaceHolder}`, "");
+    } else {
+      return standardizedPathname.replace(prefixPlaceHolder, locale);
+    }
+  }
+  return standardizedPathname.replace(`/${prefixPlaceHolder}`, "");
+};
+
+// src/adapters/next-client/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
+  };
+};
+
+// src/adapters/next-client/routing/utils/create-response.ts
+var createResponse = ({
+  request,
+  config,
+  locale,
+  responseType = "next",
+  setCookieOptions = { override: false }
+}) => {
+  const { cookie } = config;
+  const { override } = setCookieOptions;
+  const url = request.nextUrl.clone();
+  const { localePrefixedPathname } = localizePathname({
+    config,
+    pathname: url.pathname,
+    locale
+  });
+  url.pathname = localePrefixedPathname;
+  let response;
+  switch (responseType) {
+    case "next": {
+      response = server.NextResponse.next();
+      break;
+    }
+    case "redirect": {
+      response = server.NextResponse.redirect(url);
+      break;
+    }
+    default: {
+      throw new Error(`Unsupported responseType: ${responseType}`);
+    }
+  }
+  if (locale) {
+    setLocaleCookieEdge({
+      request,
+      response,
+      locale,
+      cookie,
+      override
+    });
+  }
+  const finalResponse = setPathnameHeader({ request, response });
+  return finalResponse;
+};
+var determineInitialLocale = async (config) => {
+  const { defaultLocale, supportedLocales, routing } = config;
+  let initialLocale = defaultLocale;
+  if (routing.firstVisit.localeSource === "browser") {
+    const acceptLanguageHeader = (await headers.headers()).get("accept-language") || void 0;
+    const preferredLocale = resolvePreferredLocale(
+      acceptLanguageHeader,
+      supportedLocales
+    );
+    initialLocale = normalizeLocale(preferredLocale, supportedLocales) || defaultLocale;
+  }
+  return initialLocale;
+};
+
+// src/adapters/next-client/routing/handle-prefix/handle-prefix-all.ts
+var handlePrefixAll = async ({
+  request,
+  config
+}) => {
+  var _a;
+  const { cookie, routing } = config;
+  const { maybeLocale, isLocalePrefixed } = extractPathname({
+    config,
+    pathname: request.nextUrl.pathname
+  });
+  const localeFromCookie = (_a = request.cookies.get(cookie.name)) == null ? void 0 : _a.value;
+  if (isLocalePrefixed) {
+    return createResponse({
+      request,
+      config,
+      locale: maybeLocale,
+      setCookieOptions: { override: true }
+    });
+  }
+  if (!localeFromCookie) {
+    if (!routing.firstVisit.redirect) {
+      return createResponse({ request, config });
+    }
+    const initialLocale = await determineInitialLocale(config);
+    return createResponse({
+      request,
+      config,
+      locale: initialLocale,
+      // Use locale from 'browser' | 'default'
+      responseType: "redirect"
+    });
+  }
+  return createResponse({
+    request,
+    config,
+    locale: localeFromCookie,
+    // Use locale from cookie
+    responseType: "redirect"
+  });
+};
+
+// src/adapters/next-client/routing/handle-prefix/handle-prefix-except-default.ts
+var handlePrefixExceptDefault = async ({
+  request,
+  config
+}) => {
+  var _a;
+  const { defaultLocale, cookie, routing } = config;
+  const { maybeLocale, isLocalePrefixed } = extractPathname({
+    config,
+    pathname: request.nextUrl.pathname
+  });
+  const localeFromCookie = (_a = request.cookies.get(cookie.name)) == null ? void 0 : _a.value;
+  if (isLocalePrefixed && maybeLocale !== defaultLocale) {
+    return createResponse({
+      request,
+      config,
+      locale: maybeLocale,
+      setCookieOptions: { override: true }
+    });
+  }
+  if (!localeFromCookie) {
+    if (!routing.firstVisit.redirect) {
+      return createResponse({ request, config });
+    }
+    const initialLocale = await determineInitialLocale(config);
+    const isDefaultLocale2 = initialLocale === defaultLocale;
+    if (isDefaultLocale2) {
+      return createResponse({
+        request,
+        config,
+        locale: defaultLocale
+      });
+    }
+    return createResponse({
+      request,
+      config,
+      locale: initialLocale,
+      // Use locale from 'browser' | 'default'
+      responseType: "redirect"
+    });
+  }
+  const isDefaultLocale = localeFromCookie === defaultLocale;
+  if (isDefaultLocale) {
+    return createResponse({ request, config, locale: localeFromCookie });
+  }
+  return createResponse({
+    request,
+    config,
+    locale: localeFromCookie,
+    // Use locale from cookie
+    responseType: "redirect"
+  });
+};
+
+// src/adapters/next-client/routing/handle-prefix/handle-prefix-none.ts
+var handlePrefixNone = async ({
+  request,
+  config
+}) => {
+  var _a;
+  let locale = (_a = request.cookies.get(config.cookie.name)) == null ? void 0 : _a.value;
+  if (!locale) {
+    locale = await determineInitialLocale(config);
+  }
+  return createResponse({ request, config, locale });
+};
+
+// src/adapters/next-client/routing/intor-middleware.ts
+async function intorMiddleware({
+  request,
+  config
+}) {
+  const { prefix } = config.routing;
+  if (prefix === "none") {
+    return handlePrefixNone({ request, config });
+  }
+  if (prefix === "except-default") {
+    return await handlePrefixExceptDefault({ request, config });
+  }
+  return await handlePrefixAll({ request, config });
+}
+
+// src/adapters/next-client/utils/should-use-full-reload.ts
+var shouldUseFullReload = (loaderOptions) => {
+  return (loaderOptions == null ? void 0 : loaderOptions.type) === "import" || (loaderOptions == null ? void 0 : loaderOptions.type) === "api" && loaderOptions.fullReload === true;
+};
+var Link = (_a) => {
+  var _b = _a, {
+    href,
+    locale,
+    children
+  } = _b, props = __objRest(_b, [
+    "href",
+    "locale",
+    "children"
+  ]);
+  const { config } = useIntorConfig();
+  const { locale: currentLocale, setLocale } = useIntorLocale();
+  const targetLocale = locale || currentLocale;
+  const { localePrefixedPathname } = localizePathname({
+    config,
+    pathname: href,
+    locale: targetLocale
+  });
+  href = localePrefixedPathname;
+  const handleClick = (e) => {
+    if (props.onClick) {
+      props.onClick(e);
+    }
+    if (e.defaultPrevented) {
+      return;
+    }
+    if (shouldUseFullReload(config.loaderOptions)) {
+      window.location.href = href;
+      return;
+    } else {
+      setLocale(targetLocale);
+    }
+  };
+  return /* @__PURE__ */ React6__default.default.createElement(NextLink__default.default, __spreadValues({ href, onClick: handleClick }, props), children);
+};
+var usePathname = () => {
+  const { config } = useIntorConfig();
+  const { locale } = useIntorLocale();
+  const rawPathname = navigation.usePathname();
+  const { localePrefixedPathname } = localizePathname({
+    config,
+    pathname: rawPathname,
+    locale
+  });
+  return localePrefixedPathname;
+};
+var useRouter = () => {
+  const { config } = useIntorConfig();
+  const { locale: currentLocale, setLocale } = useIntorLocale();
+  const _a = navigation.useRouter(), { push, replace } = _a, rest = __objRest(_a, ["push", "replace"]);
+  const pushWithLocale = (href, options) => {
+    const targetLocale = (options == null ? void 0 : options.locale) || currentLocale;
+    if (options == null ? void 0 : options.locale) {
+      const { localePrefixedPathname } = localizePathname({
+        config,
+        pathname: href,
+        locale: targetLocale
+      });
+      href = localePrefixedPathname;
+    }
+    if (shouldUseFullReload(config.loaderOptions)) {
+      window.location.href = href;
+      return;
+    } else {
+      setLocale(targetLocale);
+    }
+    push(href, options);
+  };
+  const replaceWithLocale = (href, options) => {
+    const targetLocale = (options == null ? void 0 : options.locale) || currentLocale;
+    if (options == null ? void 0 : options.locale) {
+      const { localePrefixedPathname } = localizePathname({
+        config,
+        pathname: href,
+        locale: targetLocale
+      });
+      href = localePrefixedPathname;
+    }
+    if (shouldUseFullReload(config.loaderOptions)) {
+      window.location.href = href;
+      return;
+    } else {
+      setLocale(targetLocale);
+    }
+    replace(href, options);
+  };
+  return __spreadValues({
+    push: pushWithLocale,
+    replace: replaceWithLocale
+  }, rest);
+};
 
+Object.defineProperty(exports, "Translator", {
+  enumerable: true,
+  get: function () { return intorTranslator.Translator; }
+});
 exports.IntorError = IntorError;
 exports.IntorErrorCode = IntorErrorCode;
+exports.IntorProvider = IntorProvider;
+exports.Link = Link;
+exports.TranslateHandlersProvider = TranslateHandlersProvider;
 exports.createIntor = createIntor;
 exports.defineIntorConfig = defineIntorConfig;
 exports.extractPathname = extractPathname;
 exports.fetchApiMessages = fetchApiMessages;
 exports.intor = intor;
+exports.intorMiddleware = intorMiddleware;
 exports.loadLocalMessages = loadLocalMessages;
 exports.mergeStaticAndDynamicMessages = mergeStaticAndDynamicMessages;
 exports.normalizeLocale = normalizeLocale;
@@ -1165,3 +1933,11 @@ exports.normalizePathname = normalizePathname;
 exports.resolveNamespaces = resolveNamespaces;
 exports.resolvePreferredLocale = resolvePreferredLocale;
 exports.standardizePathname = standardizePathname;
+exports.useIntor = useIntor;
+exports.useIntorConfig = useIntorConfig;
+exports.useIntorLocale = useIntorLocale;
+exports.useIntorMessages = useIntorMessages;
+exports.useIntorTranslator = useIntorTranslator;
+exports.usePathname = usePathname;
+exports.useRouter = useRouter;
+exports.useTranslateHandlers = useTranslateHandlers;