intor 1.0.28 → 1.0.29

package/dist/next/index.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
-var React = require('react');
+var React7 = require('react');
+var logry = require('logry');
+var intorTranslator = require('intor-translator');
 var NextLink = require('next/link');
 var navigation = require('next/navigation');
 
@@ -24,10 +26,12 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var React7__namespace = /*#__PURE__*/_interopNamespace(React7);
 var NextLink__default = /*#__PURE__*/_interopDefault(NextLink);
 
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -43,6 +47,7 @@ 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)
@@ -55,16 +60,98 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-var IntorLocaleContext = React__namespace.createContext(void 0);
-var IntorConfigContext = React__namespace.createContext(void 0);
+var IntorConfigContext = React7__namespace.createContext(void 0);
+var IntorConfigProvider = ({
+  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 = React__namespace.useContext(IntorConfigContext);
+  const context = React7__namespace.useContext(IntorConfigContext);
   if (!context) {
     throw new Error("useIntorConfig must be used within IntorConfigProvider");
   }
   return context;
 };
-var IntorMessagesContext = React__namespace.createContext(void 0);
+var IntorLocaleContext = React7__namespace.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 = React7__namespace.createContext(void 0);
 
 // src/shared/utils/pathname/normalize-pathname.ts
 var normalizePathname = (rawPathname, options = {}) => {
@@ -100,6 +187,127 @@ 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;
+    }
+    if (Array.isArray(value) && value.length > 0) {
+      value.forEach((v) => v && searchParams.append(key, v));
+    } else {
+      searchParams.append(key, value);
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    appendParam(key, value);
+  });
+  return searchParams;
+};
+var fetcher = async ({
+  apiUrl,
+  locale,
+  searchParams,
+  loggerId
+}) => {
+  const logger = logry.logry({ id: loggerId, scope: "fetcher" });
+  try {
+    const params = new URLSearchParams(searchParams);
+    params.append("locale", locale);
+    const url = `${apiUrl}?${params.toString()}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" },
+      cache: "no-store"
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Fetch failed for locale "${locale}" at URL: ${url} - ${response.status} ${response.statusText}`
+      );
+    }
+    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}`
+      );
+    }
+    return data;
+  } catch (e) {
+    logger.warn(`Failed to fetch messages for locale "${locale}".`, {
+      locale,
+      apiUrl,
+      searchParams: decodeURIComponent(searchParams.toString())
+    });
+    return void 0;
+  }
+};
+
+// src/modules/intor-messages-loader/fetch-api-messages/fetch-fallback-messages.ts
+var fetchFallbackMessages = async (apiUrl, searchParams, fallbackLocales, loggerId) => {
+  for (const fallbackLocale of fallbackLocales) {
+    const result = await fetcher({
+      apiUrl,
+      searchParams,
+      locale: fallbackLocale,
+      loggerId
+    });
+    if (result) {
+      return { locale: fallbackLocale, messages: result };
+    }
+  }
+  return void 0;
+};
+
+// src/modules/intor-messages-loader/fetch-api-messages/fetch-api-messages.ts
+var fetchApiMessages = async ({
+  apiUrl,
+  basePath,
+  locale,
+  fallbackLocales = [],
+  namespaces = [],
+  loggerId
+}) => {
+  const logger = logry.logry({ id: loggerId, scope: "fetchApiMessages" });
+  if (!apiUrl) {
+    logger.warn("No apiUrl provided for fetchApiMessages. Skipping fetch.");
+    return void 0;
+  }
+  const searchParams = buildSearchParams({
+    basePath,
+    loggerId,
+    namespaces
+  });
+  const messages = await fetcher({
+    apiUrl,
+    searchParams,
+    locale,
+    loggerId
+  });
+  if (messages) {
+    return messages;
+  }
+  const fallbackResult = await fetchFallbackMessages(
+    apiUrl,
+    searchParams,
+    fallbackLocales,
+    loggerId
+  );
+  if (fallbackResult) {
+    logger.info("Fallback locale succeeded.", {
+      usedLocale: fallbackResult.locale,
+      apiUrl,
+      searchParams: decodeURIComponent(searchParams.toString())
+    });
+    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,
@@ -152,8 +360,162 @@ var standardizePathname = ({
   const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
   return normalizePathname(standardizedPathname);
 };
+
+// src/shared/utils/resolve-namespaces.ts
+var resolveNamespaces = ({
+  config,
+  pathname
+}) => {
+  var _a, _b, _c, _d;
+  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 = (_a = routeNamespaces.default) != null ? _a : [];
+  const exactMatchNamespaces = (_b = routeNamespaces[standardizedPathname]) != null ? _b : 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 = (_d = (_c = bestNamespaces != null ? bestNamespaces : routeNamespaces["/*"]) != null ? _c : fallbackNamespaces) != null ? _d : [];
+  if (matchedNamespaces.length > 0) {
+    return [...defaultNamespaces, ...matchedNamespaces];
+  } else {
+    return [...defaultNamespaces];
+  }
+};
+
+// 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/shared/utils/merge-static-and-dynamic-messages.ts
+var mergeStaticAndDynamicMessages = (staticMessages = {}, dynamicMessages = {}) => {
+  const result = Object.keys(staticMessages).length ? __spreadValues({}, staticMessages) : {};
+  for (const locale in dynamicMessages) {
+    const dynamic = dynamicMessages[locale];
+    if (!result[locale]) {
+      result[locale] = dynamic;
+      continue;
+    }
+    result[locale] = __spreadValues(__spreadValues({}, result[locale]), dynamic);
+  }
+  return result;
+};
+
+// 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 = React7__namespace.useMemo(() => {
+    if (!config.loaderOptions) {
+      return [];
+    }
+    return resolveNamespaces({ config, pathname });
+  }, [config, pathname]);
+  const { fetcher: fetcher2 } = useFetchMessages({ onError });
+  const refetchMessages = React7__namespace.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] = React7__namespace.useState(null);
+  const [isLoadingMessages, setIsLoadingMessages] = React7__namespace.useState(false);
+  const { refetchMessages } = useRefetchMessages({
+    config,
+    pathname,
+    setLoadedMessages,
+    setIsLoadingMessages
+  });
+  const value = React7__namespace.useMemo(
+    () => ({
+      messages: loadedMessages || messages,
+      isLoading: isLoadingMessages,
+      setLoadedMessages,
+      setIsLoadingMessages,
+      refetchMessages
+    }),
+    [loadedMessages, messages, isLoadingMessages, refetchMessages]
+  );
+  return /* @__PURE__ */ React7__namespace.createElement(IntorMessagesContext.Provider, { value }, children);
+};
 var useIntorMessages = () => {
-  const context = React__namespace.useContext(IntorMessagesContext);
+  const context = React7__namespace.useContext(IntorMessagesContext);
   if (!context) {
     throw new Error(
       "useIntorMessages must be used within a IntorMessagesProvider"
@@ -161,21 +523,138 @@ var useIntorMessages = () => {
   }
   return context;
 };
+var useInitLazyLoad = ({
+  loaderOptions,
+  currentLocale
+}) => {
+  const { refetchMessages } = useIntorMessages();
+  const lazyLoad = !!(loaderOptions == null ? void 0 : loaderOptions.lazyLoad);
+  const isFirstLoadedRef = React7__namespace.useRef(false);
+  React7__namespace.useEffect(() => {
+    if (lazyLoad && !isFirstLoadedRef.current) {
+      void refetchMessages(currentLocale);
+      isFirstLoadedRef.current = true;
+    }
+  }, [lazyLoad, currentLocale, refetchMessages, isFirstLoadedRef]);
+};
+var useInitLocaleCookie = ({
+  config,
+  locale
+}) => {
+  React7__namespace.useEffect(() => {
+    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 });
+  }, []);
+};
+
+// 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] = React7__namespace.useState(initialLocale);
+  useInitLazyLoad({ loaderOptions, currentLocale });
+  useInitLocaleCookie({ config, locale: initialLocale });
+  const setLocale = React7__namespace.useCallback(
+    (newLocale) => {
+      changeLocale({
+        currentLocale,
+        newLocale,
+        loaderOptions,
+        cookie,
+        setLocale: setCurrentLocale,
+        refetchMessages
+      });
+    },
+    [currentLocale, loaderOptions, cookie, refetchMessages]
+  );
+  const value = React7__namespace.useMemo(
+    () => ({
+      locale: currentLocale,
+      setLocale
+    }),
+    [currentLocale, setLocale]
+  );
+  return /* @__PURE__ */ React7__namespace.createElement(IntorLocaleContext.Provider, { value }, children);
+};
 var useIntorLocale = () => {
-  const context = React__namespace.useContext(IntorLocaleContext);
+  const context = React7__namespace.useContext(IntorLocaleContext);
   if (!context) {
     throw new Error("useIntorLocale must be used within a IntorLocaleProvider");
   }
   return context;
 };
-var IntorTranslatorContext = React__namespace.createContext(void 0);
-var TranslateHandlersContext = React__namespace.createContext(void 0);
+var IntorTranslatorContext = React7__namespace.createContext(void 0);
+var TranslateHandlersContext = React7__namespace.createContext(void 0);
 var useTranslateHandlers = () => {
-  const context = React__namespace.useContext(TranslateHandlersContext);
+  const context = React7__namespace.useContext(TranslateHandlersContext);
   return context;
 };
+var useInitLoadingState = (config) => {
+  var _a;
+  const lazyLoad = !!((_a = config.loaderOptions) == null ? void 0 : _a.lazyLoad);
+  const [isCsr, setIsCsr] = React7__namespace.useState(false);
+  React7__namespace.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 = React7__namespace.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__ */ React7__namespace.createElement(IntorTranslatorContext.Provider, { value }, children);
+};
 function useIntorTranslator() {
-  const context = React__namespace.useContext(IntorTranslatorContext);
+  const context = React7__namespace.useContext(IntorTranslatorContext);
   if (!context) {
     throw new Error(
       "useIntorTranslator must be used within IntorTranslatorProvider"
@@ -305,7 +784,7 @@ var Link = (_a) => {
       setLocale(targetLocale);
     }
   };
-  return /* @__PURE__ */ React__namespace.createElement(NextLink__default.default, __spreadValues({ href, onClick: handleClick }, props), children);
+  return /* @__PURE__ */ React7__namespace.createElement(NextLink__default.default, __spreadValues({ href, onClick: handleClick }, props), children);
 };
 var usePathname = () => {
   const { config } = useIntorConfig();
@@ -364,7 +843,12 @@ var useRouter = () => {
   }, rest);
 };
 
+exports.IntorConfigProvider = IntorConfigProvider;
+exports.IntorLocaleProvider = IntorLocaleProvider;
+exports.IntorMessagesProvider = IntorMessagesProvider;
+exports.IntorTranslatorProvider = IntorTranslatorProvider;
 exports.Link = Link;
+exports.TranslateHandlersContext = TranslateHandlersContext;
 exports.useIntor = useIntor;
 exports.useIntorConfig = useIntorConfig;
 exports.useIntorLocale = useIntorLocale;
@@ -372,4 +856,3 @@ exports.useIntorMessages = useIntorMessages;
 exports.useIntorTranslator = useIntorTranslator;
 exports.usePathname = usePathname;
 exports.useRouter = useRouter;
-exports.useTranslateHandlers = useTranslateHandlers;