intor 2.2.14 → 2.3.0

package/dist/react/index.cjs

@@ -1,649 +0,0 @@
-'use strict';
-
-var React7 = require('react');
-var jsxRuntime = require('react/jsx-runtime');
-var logry = require('logry');
-var Keyv = require('keyv');
-var merge = require('lodash.merge');
-var intorTranslator = require('intor-translator');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var React7__namespace = /*#__PURE__*/_interopNamespace(React7);
-var Keyv__default = /*#__PURE__*/_interopDefault(Keyv);
-var merge__default = /*#__PURE__*/_interopDefault(merge);
-
-// src/client/react/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__ */ jsxRuntime.jsx(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;
-}
-
-// src/shared/utils/client/build-cookie-string.ts
-var buildCookieString = (cookie, locale) => {
-  const parts = [`${cookie.name}=${encodeURIComponent(locale)}`];
-  if (cookie.maxAge) {
-    const expires = new Date(Date.now() + cookie.maxAge * 1e3).toUTCString();
-    parts.push(`expires=${expires}`, `max-age=${cookie.maxAge}`);
-  }
-  parts.push(`path=${cookie.path ?? "/"}`);
-  if (cookie.domain) {
-    parts.push(`domain=${cookie.domain}`);
-  }
-  if (cookie.sameSite) {
-    parts.push(
-      `SameSite=${cookie.sameSite[0].toUpperCase()}${cookie.sameSite.slice(1).toLowerCase()}`
-    );
-  }
-  if (cookie.secure !== false) {
-    parts.push(`Secure`);
-  }
-  return parts.join("; ");
-};
-
-// src/shared/utils/client/set-locale-cookie-browser.ts
-var setLocaleCookieBrowser = ({
-  cookie,
-  locale
-}) => {
-  if (typeof document === "undefined") return;
-  if (!cookie.enabled || !cookie.autoSetCookie) return;
-  const cookieString = buildCookieString(cookie, locale);
-  document.cookie = cookieString;
-};
-
-// src/client/react/contexts/locale/utils/use-init-locale-cookie.ts
-var useInitLocaleCookie = ({
-  config,
-  locale
-}) => {
-  React7__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.enabled || !cookie.autoSetCookie) return;
-    setLocaleCookieBrowser({ cookie, locale });
-  }, []);
-};
-
-// src/config/constants/cache.constants.ts
-var DEFAULT_CACHE_OPTIONS = {
-  enabled: process.env.NODE_ENV === "production",
-  ttl: 60 * 60 * 1e3
-  // 1 hour
-};
-
-// src/server/shared/logger/global-logger-pool.ts
-function getGlobalLoggerPool() {
-  if (!globalThis.__INTOR_LOGGER_POOL__) {
-    globalThis.__INTOR_LOGGER_POOL__ = /* @__PURE__ */ new Map();
-  }
-  return globalThis.__INTOR_LOGGER_POOL__;
-}
-
-// src/server/shared/logger/get-logger.ts
-var DEFAULT_FORMATTER_CONFIG = {
-  node: { meta: { compact: true }, lineBreaksAfter: 1 }
-};
-function getLogger({
-  id = "default",
-  formatterConfig,
-  preset,
-  ...options
-}) {
-  const pool = getGlobalLoggerPool();
-  let logger = pool.get(id);
-  const useDefault = !formatterConfig && !preset;
-  if (!logger) {
-    logger = logry.logry({
-      id,
-      formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
-      preset,
-      ...options
-    });
-    pool.set(id, logger);
-    if (pool.size > 1e3) {
-      const keys = [...pool.keys()];
-      for (const key of keys.slice(0, 200)) pool.delete(key);
-    }
-  }
-  return logger;
-}
-
-// src/server/messages/shared/utils/is-valid-messages.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isValidMessages(value) {
-  if (!isPlainObject(value)) return false;
-  const stack = [value];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    for (const v of Object.values(current)) {
-      if (typeof v === "string") continue;
-      if (isPlainObject(v)) {
-        stack.push(v);
-      } else {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function getGlobalMessagesPool() {
-  if (!globalThis.__INTOR_MESSAGES_POOL__) {
-    globalThis.__INTOR_MESSAGES_POOL__ = new Keyv__default.default();
-  }
-  return globalThis.__INTOR_MESSAGES_POOL__;
-}
-var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  if (!loadedMessages) return { ...staticMessages };
-  return merge__default.default({}, staticMessages, loadedMessages);
-};
-
-// src/shared/utils/normalize-cache-key.ts
-var CACHE_KEY_DELIMITER = "|";
-var sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
-var normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
-  if (key === null || key === void 0) return null;
-  if (Array.isArray(key)) {
-    if (key.length === 0) return null;
-    const normalized = key.map((k) => {
-      if (k === null) return "__null";
-      if (k === void 0) return "__undefined";
-      if (typeof k === "boolean") return k ? "__true" : "__false";
-      return sanitize(String(k));
-    });
-    return normalized.join(delimiter);
-  }
-  if (typeof key === "boolean") return key ? "__true" : "__false";
-  return String(key);
-};
-
-// src/shared/constants/prefix-placeholder.ts
-var PREFIX_PLACEHOLDER = "{locale}";
-
-// src/shared/utils/resolve-namespaces.ts
-var resolveNamespaces = ({
-  config,
-  pathname
-}) => {
-  const { loader } = config;
-  const { routeNamespaces = {}, namespaces } = loader || {};
-  if (Object.keys(routeNamespaces).length === 0 && !namespaces)
-    return void 0;
-  const standardizedPathname = standardizePathname({ config, pathname });
-  const placeholderRemovedPathname = standardizedPathname.replace(
-    `/${PREFIX_PLACEHOLDER}`,
-    ""
-  );
-  const collected = [
-    ...routeNamespaces.default || [],
-    // default
-    ...namespaces || [],
-    // default
-    ...routeNamespaces[standardizedPathname] || [],
-    // exact match
-    ...routeNamespaces[placeholderRemovedPathname] || []
-    // exact match
-  ];
-  const prefixPatterns = Object.keys(routeNamespaces).filter(
-    (pattern) => pattern.endsWith("/*")
-  );
-  for (const pattern of prefixPatterns) {
-    const basePath = pattern.replace(/\/\*$/, "");
-    if (standardizedPathname.startsWith(basePath) || placeholderRemovedPathname.startsWith(basePath)) {
-      collected.push(...routeNamespaces[pattern] || []);
-    }
-  }
-  return [...new Set(collected)];
-};
-
-// src/shared/utils/pathname/normalize-pathname.ts
-var normalizePathname = (rawPathname, options = {}) => {
-  const length = rawPathname.length;
-  let start = 0;
-  let end = length - 1;
-  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
-  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
-  if (start > end) return "/";
-  let result = "";
-  let hasSlash = false;
-  for (let i = start; i <= end; i++) {
-    const char = rawPathname[i];
-    if (char === "/") {
-      if (!hasSlash) {
-        hasSlash = true;
-      }
-    } else {
-      result += hasSlash || result === "" ? "/" + char : char;
-      hasSlash = false;
-    }
-  }
-  if (options.removeLeadingSlash && result.startsWith("/")) {
-    result = result.slice(1);
-  }
-  return result || "/";
-};
-
-// src/shared/utils/pathname/standardize-pathname.ts
-var standardizePathname = ({
-  config,
-  pathname
-}) => {
-  const { routing } = config;
-  const { basePath } = routing;
-  const parts = [
-    normalizePathname(basePath),
-    PREFIX_PLACEHOLDER,
-    normalizePathname(pathname)
-  ];
-  const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-  return normalizePathname(standardizedPathname);
-};
-
-// src/server/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.ts
-var fetchLocaleMessages = async ({
-  remoteUrl,
-  remoteHeaders,
-  searchParams,
-  locale,
-  extraOptions: { loggerOptions } = {}
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
-  try {
-    const params = new URLSearchParams(searchParams);
-    params.append("locale", locale);
-    const url = `${remoteUrl}?${params.toString()}`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...remoteHeaders
-    };
-    const response = await fetch(url, {
-      method: "GET",
-      headers,
-      cache: "no-store"
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP error ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!isValidMessages(data[locale])) {
-      throw new Error("JSON file does not match NamespaceMessages structure");
-    }
-    return data;
-  } catch (error) {
-    logger.warn("Fetching locale messages failed.", {
-      locale,
-      remoteUrl,
-      searchParams: decodeURIComponent(searchParams.toString()),
-      error
-    });
-    return;
-  }
-};
-
-// src/server/messages/load-remote-messages/fetch-locale-messages/utils/build-search-params.ts
-var buildSearchParams = (params) => {
-  const searchParams = new URLSearchParams();
-  const appendParam = (key, value) => {
-    if (value === void 0 || value === null) return;
-    if (Array.isArray(value) && value.length === 0) return;
-    if (Array.isArray(value)) {
-      value.forEach((v) => v && searchParams.append(key, v));
-    } else {
-      searchParams.append(key, value);
-    }
-  };
-  Object.entries(params).forEach(([key, value]) => {
-    appendParam(key, value);
-  });
-  return searchParams;
-};
-
-// src/server/messages/load-remote-messages/load-remote-messages.ts
-var loadRemoteMessages = async ({
-  pool = getGlobalMessagesPool(),
-  rootDir,
-  remoteUrl,
-  remoteHeaders,
-  locale,
-  fallbackLocales = [],
-  namespaces = [],
-  extraOptions: {
-    cacheOptions = DEFAULT_CACHE_OPTIONS,
-    loggerOptions = { id: "default" }
-  } = {},
-  allowCacheWrite
-}) => {
-  const baseLogger = getLogger({ ...loggerOptions });
-  const logger = baseLogger.child({ scope: "load-remote-messages" });
-  const start = performance.now();
-  logger.debug("Loading remote messages from api.", { remoteUrl });
-  const key = normalizeCacheKey([
-    loggerOptions.id,
-    "loaderType:remote",
-    rootDir,
-    locale,
-    (fallbackLocales ?? []).toSorted().join(","),
-    (namespaces ?? []).toSorted().join(",")
-  ]);
-  if (cacheOptions.enabled && key) {
-    const cached = await pool?.get(key);
-    if (cached) {
-      logger.debug("Messages cache hit.", { key });
-      return cached;
-    }
-  }
-  const searchParams = buildSearchParams({ rootDir, namespaces });
-  const candidateLocales = [locale, ...fallbackLocales || []];
-  let messages;
-  for (const candidateLocale of candidateLocales) {
-    try {
-      const result = await fetchLocaleMessages({
-        remoteUrl,
-        remoteHeaders,
-        searchParams,
-        locale: candidateLocale,
-        extraOptions: { loggerOptions }
-      });
-      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
-        messages = result;
-        break;
-      }
-    } catch (error) {
-      logger.error("Failed to fetch locale messages.", {
-        locale: candidateLocale,
-        error
-      });
-    }
-  }
-  if (allowCacheWrite && cacheOptions.enabled && key && messages) {
-    await pool?.set(key, messages, cacheOptions.ttl);
-  }
-  const end = performance.now();
-  const duration = Math.round(end - start);
-  logger.trace("Finished loading remote messages.", {
-    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
-    duration: `${duration} ms`
-  });
-  return messages;
-};
-
-// src/client/react/contexts/messages/utils/use-refetch-messages.ts
-var useRefetchMessages = ({
-  config,
-  pathname,
-  setLoadedMessages,
-  setIsLoadingMessages
-}) => {
-  const { messages: staticMessages, loader } = config;
-  const namespaces = React7__namespace.useMemo(() => {
-    if (!loader) return [];
-    return resolveNamespaces({ config, pathname });
-  }, [config, pathname]);
-  const refetchMessages = React7__namespace.useCallback(
-    async (newLocale) => {
-      if (loader?.type === "remote") {
-        setIsLoadingMessages(true);
-        const loadedMessages = await loadRemoteMessages({
-          rootDir: loader.rootDir,
-          remoteUrl: loader.remoteUrl,
-          remoteHeaders: loader.remoteHeaders,
-          locale: newLocale,
-          fallbackLocales: config.fallbackLocales[newLocale] || [],
-          namespaces,
-          extraOptions: {
-            cacheOptions: config.cache,
-            loggerOptions: { id: config.id }
-          }
-        });
-        const messages = mergeMessages(staticMessages, loadedMessages);
-        setLoadedMessages(messages);
-        setIsLoadingMessages(false);
-      }
-    },
-    [
-      loader,
-      config.fallbackLocales,
-      config.cache,
-      config.id,
-      setIsLoadingMessages,
-      namespaces,
-      staticMessages,
-      setLoadedMessages
-    ]
-  );
-  return { refetchMessages };
-};
-var MessagesContext = React7__namespace.createContext(void 0);
-function MessagesProvider({
-  value: { messages = {} },
-  children
-}) {
-  const { config, pathname } = useConfig();
-  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__ */ jsxRuntime.jsx(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 LocaleContext = React7__namespace.createContext(void 0);
-
-// src/client/react/contexts/locale/utils/change-locale.ts
-var changeLocale = ({
-  currentLocale,
-  newLocale,
-  loader,
-  cookie,
-  setLocale,
-  refetchMessages
-}) => {
-  if (typeof document === "undefined") return;
-  const { type } = loader || {};
-  if (newLocale === currentLocale) return;
-  if (type === "local") {
-    console.warn(
-      `[Intor] You are using "loader type: local" to switch languages. Please make sure to use the wrapped <Link> component to trigger a page reload, ensuring that the translation data is dynamically updated.`
-    );
-  }
-  setLocale(newLocale);
-  setLocaleCookieBrowser({ cookie, locale: newLocale });
-  document.documentElement.lang = newLocale;
-  if (type === "remote" && refetchMessages) {
-    void refetchMessages(newLocale);
-  }
-};
-function LocaleProvider({
-  value: { initialLocale, onLocaleChange },
-  children
-}) {
-  const { config } = useConfig();
-  const { refetchMessages } = useMessages();
-  const { loader, cookie } = config;
-  const [currentLocale, setCurrentLocale] = React7__namespace.useState(initialLocale);
-  useInitLocaleCookie({ config, locale: initialLocale });
-  const setLocale = React7__namespace.useCallback(
-    async (newLocale) => {
-      changeLocale({
-        currentLocale,
-        newLocale,
-        loader,
-        cookie,
-        setLocale: setCurrentLocale,
-        refetchMessages
-      });
-      onLocaleChange?.(newLocale);
-    },
-    [currentLocale, loader, cookie, refetchMessages, onLocaleChange]
-  );
-  const value = React7__namespace.useMemo(
-    () => ({
-      locale: currentLocale,
-      setLocale
-    }),
-    [currentLocale, setLocale]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(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 TranslateHandlersContext = React7__namespace.createContext(void 0);
-var TranslateHandlersProvider = ({
-  handlers,
-  children
-}) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(TranslateHandlersContext.Provider, { value: handlers, children });
-};
-function useTranslateHandlers() {
-  const context = React7__namespace.useContext(TranslateHandlersContext);
-  return context;
-}
-var TranslatorContext = React7__namespace.createContext(void 0);
-function TranslatorProvider({
-  value: { isLoading: externalIsLoading },
-  children
-}) {
-  const { config } = useConfig();
-  const { messages, isLoading: internalIsLoading } = useMessages();
-  const { locale } = useLocale();
-  const translateHandlers = useTranslateHandlers();
-  const { fallbackLocales, translator: translatorOptions } = config;
-  const isLoading = Boolean(externalIsLoading ?? internalIsLoading);
-  const translator = React7__namespace.useMemo(() => {
-    return new intorTranslator.Translator({
-      messages,
-      locale,
-      isLoading,
-      fallbackLocales,
-      loadingMessage: translatorOptions?.loadingMessage,
-      placeholder: translatorOptions?.placeholder,
-      handlers: translateHandlers
-    });
-  }, [
-    messages,
-    locale,
-    isLoading,
-    fallbackLocales,
-    translateHandlers,
-    translatorOptions?.loadingMessage,
-    translatorOptions?.placeholder
-  ]);
-  return /* @__PURE__ */ jsxRuntime.jsx(TranslatorContext.Provider, { value: { translator }, children });
-}
-function useTranslator() {
-  const context = React7__namespace.useContext(TranslatorContext);
-  if (!context)
-    throw new Error(
-      "useTranslator must be used within IntorTranslatorProvider"
-    );
-  return context;
-}
-var IntorProvider = ({
-  value: {
-    config,
-    pathname = "",
-    initialLocale,
-    messages = config.messages,
-    onLocaleChange,
-    isLoading
-  },
-  children
-}) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(ConfigProvider, { value: { config, pathname }, children: /* @__PURE__ */ jsxRuntime.jsx(MessagesProvider, { value: { messages }, children: /* @__PURE__ */ jsxRuntime.jsx(LocaleProvider, { value: { initialLocale, onLocaleChange }, children: /* @__PURE__ */ jsxRuntime.jsx(TranslatorProvider, { value: { isLoading }, children }) }) }) });
-};
-
-// src/client/react/hooks/use-translator.ts
-function useTranslator2(preKey) {
-  const { translator } = useTranslator();
-  const { setLocale } = useLocale();
-  const props = {
-    messages: translator.messages,
-    locale: translator.locale,
-    isLoading: translator.isLoading,
-    setLocale
-  };
-  const scoped = translator.scoped(preKey);
-  return {
-    ...props,
-    hasKey: preKey ? scoped.hasKey : translator.hasKey,
-    t: preKey ? scoped.t : translator.t
-  };
-}
-
-// src/client/shared/utils/get-initial-locale.ts
-function getInitialLocale(config, cookieName = config.cookie.name) {
-  const { defaultLocale, supportedLocales } = config;
-  const match = document.cookie.match(
-    new RegExp(
-      `(?:^|; )${cookieName.replaceAll(/([.$?*|{}()[\]\\/+^])/g, String.raw`\$1`)}=([^;]*)`
-    )
-  );
-  const cookieLocale = match ? decodeURIComponent(match[1]) : null;
-  const browserLocale = navigator.languages?.[0] || navigator.language;
-  const locale = cookieLocale || browserLocale || defaultLocale;
-  const normalized = locale.toLowerCase();
-  const matched = supportedLocales.find((l) => l.toLowerCase() === normalized);
-  return matched ?? defaultLocale;
-}
-
-exports.IntorProvider = IntorProvider;
-exports.TranslateHandlersProvider = TranslateHandlersProvider;
-exports.getInitialLocale = getInitialLocale;
-exports.useTranslator = useTranslator2;