intor 2.2.1 → 2.2.3

package/dist/next/index.js

@@ -1,6 +1,7 @@
-import * as React7 from 'react';
+import * as React6 from 'react';
 import { logry } from 'logry';
 import Keyv from 'keyv';
+import merge from 'lodash.merge';
 import { Translator } from 'intor-translator';
 import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
 import NextLink from 'next/link';
@@ -8,21 +9,21 @@ import { usePathname as usePathname$1, useRouter as useRouter$1, redirect as red
 import { cookies, headers } from 'next/headers';
 
 // src/adapters/next/contexts/intor-provider/intor-provider.tsx
-var ConfigContext = React7.createContext(void 0);
+var ConfigContext = React6.createContext(void 0);
+
+// src/adapters/next/contexts/config/provider.tsx
 function ConfigProvider({
   value: { config, pathname },
   children
 }) {
-  const value = React7.useMemo(() => ({ config, pathname }), [config, pathname]);
-  return /* @__PURE__ */ React7.createElement(ConfigContext.Provider, { value }, children);
+  const value = React6.useMemo(() => ({ config, pathname }), [config, pathname]);
+  return /* @__PURE__ */ React6.createElement(ConfigContext.Provider, { value }, children);
 }
 function useConfig() {
-  const context = React7.useContext(ConfigContext);
+  const context = React6.useContext(ConfigContext);
   if (!context) throw new Error("useConfig must be used within ConfigProvider");
   return context;
 }
-var LocaleContext = React7.createContext(void 0);
-var MessagesContext = React7.createContext(void 0);
 
 // src/modules/config/constants/cache.constants.ts
 var DEFAULT_CACHE_OPTIONS = {
@@ -44,17 +45,18 @@ var DEFAULT_FORMATTER_CONFIG = {
   node: { meta: { compact: true }, lineBreaksAfter: 1 }
 };
 function getLogger({
-  id,
+  id = "default",
   formatterConfig,
   preset,
   ...options
 }) {
   const pool = getGlobalLoggerPool();
   let logger = pool.get(id);
+  const useDefault = !formatterConfig && !preset;
   if (!logger) {
     logger = logry({
       id,
-      formatterConfig: !formatterConfig && !preset ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
+      formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
       preset,
       ...options
     });
@@ -66,28 +68,36 @@ function getLogger({
   }
   return logger;
 }
+
+// src/modules/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/shared/utils/merge-messages.ts
 var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  const result = Object.keys(staticMessages).length > 0 ? { ...staticMessages } : {};
-  for (const locale in loadedMessages) {
-    const loaded = loadedMessages[locale];
-    if (!result[locale]) {
-      result[locale] = loaded;
-      continue;
-    }
-    result[locale] = {
-      ...result[locale],
-      ...loaded
-    };
-  }
-  return result;
+  if (!loadedMessages) return { ...staticMessages };
+  return merge({}, staticMessages, loadedMessages);
 };
 
 // src/shared/utils/normalize-cache-key.ts
@@ -119,6 +129,8 @@ var resolveNamespaces = ({
 }) => {
   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}`,
@@ -274,23 +286,23 @@ var standardizePathname = ({
   return normalizePathname(standardizedPathname);
 };
 
-// src/modules/messages/load-api-messages/fetch-messages.ts
-var fetchMessages = async ({
-  apiUrl,
-  apiHeaders,
-  locale,
+// src/modules/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.ts
+var fetchLocaleMessages = async ({
+  remoteUrl,
+  remoteHeaders,
   searchParams,
-  logger: loggerOptions = { id: "default" }
+  locale,
+  extraOptions: { loggerOptions } = {}
 }) => {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "fetch-messages" });
+  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
   try {
     const params = new URLSearchParams(searchParams);
     params.append("locale", locale);
-    const url = `${apiUrl}?${params.toString()}`;
+    const url = `${remoteUrl}?${params.toString()}`;
     const headers2 = {
       "Content-Type": "application/json",
-      ...apiHeaders
+      ...remoteHeaders
     };
     const response = await fetch(url, {
       method: "GET",
@@ -298,17 +310,17 @@ var fetchMessages = async ({
       cache: "no-store"
     });
     if (!response.ok) {
-      throw new Error(`Fetch failed: ${locale} (${response.status})`);
+      throw new Error(`HTTP error ${response.status} ${response.statusText}`);
     }
     const data = await response.json();
-    if (data == null || typeof data === "object" && Object.keys(data).length === 0) {
-      throw new Error(`Invalid messages: ${locale}`);
+    if (!isValidMessages(data[locale])) {
+      throw new Error("JSON file does not match NamespaceMessages structure");
     }
     return data;
   } catch (error) {
-    logger.warn(`Failed to fetch messages for locale "${locale}".`, {
+    logger.warn("Fetching locale messages failed.", {
       locale,
-      apiUrl,
+      remoteUrl,
       searchParams: decodeURIComponent(searchParams.toString()),
       error
     });
@@ -316,30 +328,7 @@ var fetchMessages = async ({
   }
 };
 
-// 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 fetchMessages({
-      apiUrl,
-      searchParams,
-      locale: fallbackLocale,
-      apiHeaders,
-      logger
-    });
-    if (result) {
-      return { locale: fallbackLocale, messages: result };
-    }
-  }
-  return;
-};
-
-// src/modules/messages/load-api-messages/utils/build-search-params.ts
+// src/modules/messages/load-remote-messages/fetch-locale-messages/utils/build-search-params.ts
 var buildSearchParams = (params) => {
   const searchParams = new URLSearchParams();
   const appendParam = (key, value) => {
@@ -357,78 +346,72 @@ var buildSearchParams = (params) => {
   return searchParams;
 };
 
-// src/modules/messages/load-api-messages/load-api-messages.ts
-var loadApiMessages = async ({
-  apiUrl,
-  apiHeaders,
-  basePath,
+// src/modules/messages/load-remote-messages/load-remote-messages.ts
+var loadRemoteMessages = async ({
+  pool = getGlobalMessagesPool(),
+  rootDir,
+  remoteUrl,
+  remoteHeaders,
   locale,
   fallbackLocales = [],
   namespaces = [],
-  cache = DEFAULT_CACHE_OPTIONS,
-  logger: loggerOptions = { id: "default" }
+  extraOptions: {
+    cacheOptions = DEFAULT_CACHE_OPTIONS,
+    loggerOptions = { id: "default" }
+  } = {}
 }) => {
   const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-api-messages" });
-  if (!apiUrl) {
-    logger.warn("No apiUrl provided. Skipping fetch.");
-    return;
-  }
-  let pool;
-  if (cache.enabled) {
-    pool = getGlobalMessagesPool();
-  }
+  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,
-    basePath,
+    "loaderType:remote",
+    rootDir,
     locale,
     (fallbackLocales ?? []).toSorted().join(","),
     (namespaces ?? []).toSorted().join(",")
   ]);
-  if (cache.enabled && key) {
+  if (cacheOptions.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,
-    logger: loggerOptions
-  });
-  if (messages) {
-    if (cache.enabled && key) {
-      await pool?.set(key, messages, cache.ttl);
+  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
+      });
     }
-    return messages;
   }
-  const fallbackResult = await fetchFallbackMessages({
-    apiUrl,
-    apiHeaders,
-    searchParams,
-    fallbackLocales,
-    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;
+  if (cacheOptions.enabled && key && messages) {
+    await pool?.set(key, messages, cacheOptions.ttl);
   }
-  logger.warn("Failed to fetch messages for all locales.", {
-    locale,
-    fallbackLocales
+  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;
+  return messages;
 };
 
 // src/adapters/next/contexts/messages/utils/use-refetch-messages.ts
@@ -439,20 +422,25 @@ var useRefetchMessages = ({
   setIsLoadingMessages
 }) => {
   const { messages: staticMessages } = config;
-  const namespaces = React7.useMemo(() => {
+  const namespaces = React6.useMemo(() => {
     if (!config.loader) return [];
     return resolveNamespaces({ config, pathname });
   }, [config, pathname]);
-  const refetchMessages = React7.useCallback(
+  const refetchMessages = React6.useCallback(
     async (newLocale) => {
-      if (config.loader?.type === "api") {
+      if (config.loader?.type === "remote") {
         setIsLoadingMessages(true);
-        const loadedMessages = await loadApiMessages({
-          ...config.loader,
+        const loadedMessages = await loadRemoteMessages({
+          rootDir: config.loader.rootDir,
+          remoteUrl: config.loader.remoteUrl,
+          remoteHeaders: config.loader.remoteHeaders,
           locale: newLocale,
           fallbackLocales: config.fallbackLocales[newLocale] || [],
           namespaces,
-          logger: { id: config.id }
+          extraOptions: {
+            cacheOptions: config.cache,
+            loggerOptions: { id: config.id }
+          }
         });
         const messages = mergeMessages(staticMessages, loadedMessages);
         setLoadedMessages(messages);
@@ -471,6 +459,7 @@ var useRefetchMessages = ({
   );
   return { refetchMessages };
 };
+var MessagesContext = React6.createContext(void 0);
 
 // src/adapters/next/contexts/messages/provider.tsx
 function MessagesProvider({
@@ -478,15 +467,15 @@ function MessagesProvider({
   children
 }) {
   const { config, pathname } = useConfig();
-  const [loadedMessages, setLoadedMessages] = React7.useState(null);
-  const [isLoadingMessages, setIsLoadingMessages] = React7.useState(false);
+  const [loadedMessages, setLoadedMessages] = React6.useState(null);
+  const [isLoadingMessages, setIsLoadingMessages] = React6.useState(false);
   const { refetchMessages } = useRefetchMessages({
     config,
     pathname,
     setLoadedMessages,
     setIsLoadingMessages
   });
-  const value = React7.useMemo(
+  const value = React6.useMemo(
     () => ({
       messages: loadedMessages || messages,
       isLoading: isLoadingMessages,
@@ -496,10 +485,10 @@ function MessagesProvider({
     }),
     [loadedMessages, messages, isLoadingMessages, refetchMessages]
   );
-  return /* @__PURE__ */ React7.createElement(MessagesContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6.createElement(MessagesContext.Provider, { value }, children);
 }
 function useMessages() {
-  const context = React7.useContext(MessagesContext);
+  const context = React6.useContext(MessagesContext);
   if (!context)
     throw new Error("useMessages must be used within a MessagesProvider");
   return context;
@@ -512,8 +501,8 @@ var useInitLazyLoad = ({
 }) => {
   const { refetchMessages } = useMessages();
   const lazyLoad = !!loaderOptions?.lazyLoad;
-  const isFirstLoadedRef = React7.useRef(false);
-  React7.useEffect(() => {
+  const isFirstLoadedRef = React6.useRef(false);
+  React6.useEffect(() => {
     if (lazyLoad && !isFirstLoadedRef.current) {
       void refetchMessages(currentLocale);
       isFirstLoadedRef.current = true;
@@ -559,7 +548,7 @@ var useInitLocaleCookie = ({
   config,
   locale
 }) => {
-  React7.useEffect(() => {
+  React6.useEffect(() => {
     if (typeof document === "undefined") return;
     const { cookie, routing } = config;
     const { firstVisit } = routing;
@@ -571,6 +560,7 @@ var useInitLocaleCookie = ({
     setLocaleCookieBrowser({ cookie, locale });
   }, []);
 };
+var LocaleContext = React6.createContext(void 0);
 
 // src/adapters/next/contexts/locale/utils/change-locale.ts
 var changeLocale = ({
@@ -584,15 +574,15 @@ var changeLocale = ({
   if (typeof document === "undefined") return;
   const loaderType = loaderOptions?.type;
   if (newLocale === currentLocale) return;
-  if (loaderType === "import") {
+  if (loaderType === "local") {
     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.`
+      `[Intor] You are using dynamic 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 (loaderType === "api" && refetchMessages) {
+  if (loaderType === "remote" && refetchMessages) {
     void refetchMessages(newLocale);
   }
 };
@@ -605,10 +595,10 @@ function LocaleProvider({
   const { config } = useConfig();
   const { refetchMessages } = useMessages();
   const { loader: loaderOptions, cookie } = config;
-  const [currentLocale, setCurrentLocale] = React7.useState(initialLocale);
+  const [currentLocale, setCurrentLocale] = React6.useState(initialLocale);
   useInitLazyLoad({ loaderOptions, currentLocale });
   useInitLocaleCookie({ config, locale: initialLocale });
-  const setLocale = React7.useCallback(
+  const setLocale = React6.useCallback(
     (newLocale) => {
       changeLocale({
         currentLocale,
@@ -621,43 +611,45 @@ function LocaleProvider({
     },
     [currentLocale, loaderOptions, cookie, refetchMessages]
   );
-  const value = React7.useMemo(
+  const value = React6.useMemo(
     () => ({
       locale: currentLocale,
       setLocale
     }),
     [currentLocale, setLocale]
   );
-  return /* @__PURE__ */ React7.createElement(LocaleContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6.createElement(LocaleContext.Provider, { value }, children);
 }
 function useLocale() {
-  const context = React7.useContext(LocaleContext);
+  const context = React6.useContext(LocaleContext);
   if (!context)
     throw new Error("useLocale must be used within a LocaleProvider");
   return context;
 }
-var TranslatorContext = React7.createContext(void 0);
-var TranslateHandlersContext = React7.createContext(void 0);
+var TranslateHandlersContext = React6.createContext(void 0);
+
+// src/adapters/next/contexts/translate-handlers/provider.tsx
 var TranslateHandlersProvider = ({
   children,
   handlers
 }) => {
   const value = handlers;
-  return /* @__PURE__ */ React7.createElement(TranslateHandlersContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6.createElement(TranslateHandlersContext.Provider, { value }, children);
 };
 function useTranslateHandlers() {
-  const context = React7.useContext(TranslateHandlersContext);
+  const context = React6.useContext(TranslateHandlersContext);
   return context;
 }
 var useInitLoadingState = (config) => {
   const lazyLoad = !!config.loader?.lazyLoad;
-  const [isCsr, setIsCsr] = React7.useState(false);
-  React7.useEffect(() => {
+  const [isCsr, setIsCsr] = React6.useState(false);
+  React6.useEffect(() => {
     setIsCsr(true);
   }, []);
   const isBeforeCSRLoading = lazyLoad && !isCsr;
   return isBeforeCSRLoading;
 };
+var TranslatorContext = React6.createContext(void 0);
 
 // src/adapters/next/contexts/translator/provider.tsx
 var EMPTY_OBJECT = Object.freeze({});
@@ -668,7 +660,7 @@ function TranslatorProvider({ children }) {
   const translatorHandlers = useTranslateHandlers();
   const { fallbackLocales, translator: translatorOptions } = config;
   const isBeforeCSRLoading = useInitLoadingState(config);
-  const value = React7.useMemo(() => {
+  const value = React6.useMemo(() => {
     const translator = new Translator({
       messages: messages || EMPTY_OBJECT,
       locale,
@@ -689,10 +681,10 @@ function TranslatorProvider({ children }) {
     translatorOptions?.loadingMessage,
     translatorOptions?.placeholder
   ]);
-  return /* @__PURE__ */ React7.createElement(TranslatorContext.Provider, { value }, children);
+  return /* @__PURE__ */ React6.createElement(TranslatorContext.Provider, { value }, children);
 }
 function useTranslator() {
-  const context = React7.useContext(TranslatorContext);
+  const context = React6.useContext(TranslatorContext);
   if (!context)
     throw new Error(
       "useTranslator must be used within IntorTranslatorProvider"
@@ -705,7 +697,7 @@ var IntorProvider = ({
   value: { config, pathname, initialLocale, messages },
   children
 }) => {
-  return /* @__PURE__ */ React7.createElement(ConfigProvider, { value: { config, pathname } }, /* @__PURE__ */ React7.createElement(MessagesProvider, { value: { messages } }, /* @__PURE__ */ React7.createElement(LocaleProvider, { value: { initialLocale } }, /* @__PURE__ */ React7.createElement(TranslatorProvider, null, children))));
+  return /* @__PURE__ */ React6.createElement(ConfigProvider, { value: { config, pathname } }, /* @__PURE__ */ React6.createElement(MessagesProvider, { value: { messages } }, /* @__PURE__ */ React6.createElement(LocaleProvider, { value: { initialLocale } }, /* @__PURE__ */ React6.createElement(TranslatorProvider, null, children))));
 };
 
 // src/adapters/next/hooks/use-translator/use-translator.ts
@@ -802,7 +794,7 @@ var shouldFullReload = ({
 }) => {
   const loader = config.loader;
   if (!loader || !loader.type) return false;
-  if (loader.type === "api" && !loader.fullReload) return false;
+  if (loader.type === "remote" && !loader.fullReload) return false;
   const { maybeLocale, isLocalePrefixed } = extractPathname({
     config,
     pathname: targetPathname
@@ -864,7 +856,7 @@ var Link = ({
     onClick?.(e);
     switchLocale({ href: formatted, locale });
   };
-  return /* @__PURE__ */ React7.createElement(NextLink, { href: resolvedHref, onClick: handleClick, ...props }, children);
+  return /* @__PURE__ */ React6.createElement(NextLink, { href: resolvedHref, onClick: handleClick, ...props }, children);
 };
 var useRouter = () => {
   const { push, replace, ...rest } = useRouter$1();

package/dist/next/middleware/index.d.cts

@@ -42,28 +42,28 @@ type RouteNamespaces = {
     [key: string]: string[];
     default: string[];
 };
-interface ApiHeaders {
+interface RemoteHeaders {
     authorization?: string;
     "x-api-key"?: string;
     [key: string]: string | undefined;
 }
 type BaseLoaderOptions = {
-    basePath?: string;
+    rootDir?: string;
     namespaces?: string[];
     routeNamespaces?: RouteNamespaces;
     concurrency?: number;
     lazyLoad?: boolean;
 };
-type ImportLoader = BaseLoaderOptions & {
-    type: "import";
+type LocalLoader = BaseLoaderOptions & {
+    type: "local";
 };
-type ApiLoader = BaseLoaderOptions & {
-    type: "api";
-    apiUrl: string;
-    apiHeaders?: ApiHeaders;
+type RemoteLoader = BaseLoaderOptions & {
+    type: "remote";
+    remoteUrl: string;
+    remoteHeaders?: RemoteHeaders;
     fullReload?: boolean;
 };
-type LoaderOptions = ImportLoader | ApiLoader;
+type LoaderOptions = LocalLoader | RemoteLoader;
 
 type LoggerOptions = {
     level?: Level;

package/dist/next/middleware/index.d.ts

@@ -42,28 +42,28 @@ type RouteNamespaces = {
     [key: string]: string[];
     default: string[];
 };
-interface ApiHeaders {
+interface RemoteHeaders {
     authorization?: string;
     "x-api-key"?: string;
     [key: string]: string | undefined;
 }
 type BaseLoaderOptions = {
-    basePath?: string;
+    rootDir?: string;
     namespaces?: string[];
     routeNamespaces?: RouteNamespaces;
     concurrency?: number;
     lazyLoad?: boolean;
 };
-type ImportLoader = BaseLoaderOptions & {
-    type: "import";
+type LocalLoader = BaseLoaderOptions & {
+    type: "local";
 };
-type ApiLoader = BaseLoaderOptions & {
-    type: "api";
-    apiUrl: string;
-    apiHeaders?: ApiHeaders;
+type RemoteLoader = BaseLoaderOptions & {
+    type: "remote";
+    remoteUrl: string;
+    remoteHeaders?: RemoteHeaders;
     fullReload?: boolean;
 };
-type LoaderOptions = ImportLoader | ApiLoader;
+type LoaderOptions = LocalLoader | RemoteLoader;
 
 type LoggerOptions = {
     level?: Level;