intor-translator 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -1,37 +1,83 @@
 'use strict';
 
-var intorCache = require('intor-cache');
-
-// src/methods/get-locale/get-locale.ts
-var getLocale = (localeRef) => {
-  return localeRef.current;
+// src/cache/cache.ts
+var Cache = class {
+  constructor(maxSize = 100, ttl = 1e3 * 60 * 5) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+    this.ttl = ttl;
+  }
+  // Clean up expired cache entries
+  cleanUp() {
+    const now = Date.now();
+    this.cache.forEach((entry, key) => {
+      if (now - entry.timestamp > this.ttl) {
+        this.cache.delete(key);
+      }
+    });
+  }
+  // Get cache data
+  get(key) {
+    this.cleanUp();
+    const entry = this.cache.get(key);
+    if (entry) {
+      entry.timestamp = Date.now();
+      return entry.value;
+    }
+    return void 0;
+  }
+  // Set cache data
+  set(key, value) {
+    this.cleanUp();
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, { value, timestamp: Date.now() });
+  }
+  // Check if a key exists in the cache
+  has(key) {
+    this.cleanUp();
+    return this.cache.has(key);
+  }
+  // Clear all cache
+  clear() {
+    this.cache.clear();
+  }
 };
 
-// src/methods/get-locale/create-get-locale.ts
-var createGetLocale = (localeRef) => {
-  return () => getLocale(localeRef);
+// src/cache/message-key-cache.ts
+var MESSAGE_KEY_CACHE_MAX_SIZE = 100;
+var MESSAGE_KEY_CACHE_EXPIRES_TIME = 1e3 * 60 * 5;
+var messageKeyCache;
+var getMessageKeyCache = () => {
+  if (typeof window !== "undefined" && !messageKeyCache) {
+    messageKeyCache = new Cache(
+      MESSAGE_KEY_CACHE_MAX_SIZE,
+      MESSAGE_KEY_CACHE_EXPIRES_TIME
+    );
+  }
+  return messageKeyCache;
 };
-
-// src/methods/get-messages/get-messages.ts
-var getMessages = (messagesRef) => {
-  return messagesRef.current;
+var clearMessageKeyCache = () => {
+  if (messageKeyCache) {
+    messageKeyCache.clear();
+    messageKeyCache = void 0;
+  }
 };
 
-// src/methods/get-messages/create-get-messages.ts
-var createGetMessages = (messagesRef) => {
-  return () => getMessages(messagesRef);
-};
+// src/utils/get-value-by-key.ts
 var getValueByKey = (locale, messages, key, useCache = true) => {
-  const cache = intorCache.getMessageKeyCache();
+  const cache = getMessageKeyCache();
   useCache = Boolean(useCache && cache);
   const cacheKey = `${key}`;
-  const currentLocale = cache == null ? void 0 : cache.get("locale");
+  const currentLocale = cache?.get("locale");
   if (currentLocale !== locale) {
-    cache == null ? void 0 : cache.clear();
-    cache == null ? void 0 : cache.set("locale", locale);
+    cache?.clear();
+    cache?.set("locale", locale);
   }
-  if (useCache && (cache == null ? void 0 : cache.has(cacheKey))) {
-    return cache == null ? void 0 : cache.get(cacheKey);
+  if (useCache && cache?.has(cacheKey)) {
+    return cache?.get(cacheKey);
   }
   const value = key.split(".").reduce((acc, key2) => {
     if (acc && typeof acc === "object" && key2 in acc) {
@@ -40,7 +86,7 @@ var getValueByKey = (locale, messages, key, useCache = true) => {
     return void 0;
   }, messages);
   if (useCache && value !== void 0) {
-    cache == null ? void 0 : cache.set(cacheKey, value);
+    cache?.set(cacheKey, value);
   }
   return value;
 };
@@ -66,49 +112,22 @@ var findMessageInLocales = ({
 
 // src/utils/resolve-locales-to-try.ts
 var resolveLocalesToTry = (locale, fallbackLocales) => {
-  const fallbacks = (fallbackLocales == null ? void 0 : fallbackLocales[locale]) || [];
-  return [
-    locale,
-    ...fallbacks.filter((l) => l !== locale)
-  ];
+  const fallbacks = fallbackLocales?.[locale] || [];
+  const filteredFallbacks = fallbacks.filter((l) => l !== locale);
+  return [locale, ...filteredFallbacks];
 };
 
-// src/methods/has-key/has-key.ts
+// src/translator-methods/has-key/has-key.ts
 var hasKey = ({
   messagesRef,
   localeRef,
-  translatorOptions,
   key,
-  locale
+  targetLocale
 }) => {
   const messages = messagesRef.current;
-  const { fallbackLocales } = translatorOptions;
-  const targetLocale = locale != null ? locale : localeRef.current;
-  const localesToTry = resolveLocalesToTry(targetLocale, fallbackLocales);
-  const message = findMessageInLocales({ messages, localesToTry, key });
-  return message ? true : false;
-};
-
-// src/methods/has-key/create-has-key.ts
-var createHasKey = (messagesRef, localeRef, translatorOptions) => {
-  return (key, locale) => hasKey({
-    messagesRef,
-    localeRef,
-    translatorOptions,
-    key,
-    locale
-  });
-};
-
-// src/utils/get-full-key.ts
-var getFullKey = (preKey, key) => {
-  if (!preKey) {
-    return key;
-  }
-  if (!key) {
-    return preKey;
-  }
-  return `${preKey}.${key}`;
+  const locale = localeRef.current;
+  const localesToTry = resolveLocalesToTry(targetLocale || locale);
+  return findMessageInLocales({ messages, localesToTry, key }) ? true : false;
 };
 
 // src/utils/replace-values.ts
@@ -130,24 +149,32 @@ var replaceValues = (message, params) => {
   return replaced;
 };
 
-// src/methods/translate/translate.ts
+// src/translator-methods/translate/translate.ts
 var translate = ({
   messagesRef,
   localeRef,
-  translatorOptions,
+  isLoadingRef,
+  translateConfig,
   key,
   replacements
 }) => {
   const messages = messagesRef.current;
-  const { fallbackLocales, isLoading, loadingMessage, placeholder } = translatorOptions;
-  const { messageFormatter, loadingMessageHandler, placeholderHandler } = translatorOptions.handlers || {};
-  const localesToTry = resolveLocalesToTry(localeRef.current, fallbackLocales);
+  const locale = localeRef.current;
+  const isLoading = isLoadingRef.current;
+  const {
+    fallbackLocales,
+    loadingMessage,
+    placeholder,
+    handlers = {}
+  } = translateConfig;
+  const { formatMessage, onLoading, onMissing } = handlers;
+  const localesToTry = resolveLocalesToTry(locale, fallbackLocales);
   const message = findMessageInLocales({ messages, localesToTry, key });
   if (isLoading) {
-    if (loadingMessageHandler) {
-      return loadingMessageHandler({
+    if (onLoading) {
+      return onLoading({
         key,
-        locale: localeRef.current,
+        locale,
         replacements
       });
     }
@@ -156,113 +183,136 @@ var translate = ({
     }
   }
   if (!message) {
-    if (placeholderHandler) {
-      return placeholderHandler({
-        key,
-        locale: localeRef.current,
-        replacements
-      });
+    if (onMissing) {
+      return onMissing({ key, locale, replacements });
     }
     if (placeholder) {
       return placeholder;
     }
     return key;
   }
-  if (messageFormatter) {
-    return messageFormatter({
-      message,
-      key,
-      locale: localeRef.current,
-      replacements
-    });
+  if (formatMessage) {
+    return formatMessage({ message, key, locale, replacements });
   } else {
     return replacements ? replaceValues(message, replacements) : message;
   }
 };
 
-// src/methods/translate/create-translate.ts
-var createTranslate = (messagesRef, localeRef, translatorOptions) => {
-  return (key, replacements) => translate({
-    messagesRef,
-    localeRef,
-    translatorOptions,
-    key,
-    replacements
-  });
-};
-
-// src/methods/scoped/scoped.ts
-var scoped = ({
-  messagesRef,
-  localeRef,
-  translatorOptions,
-  preKey
-}) => {
-  const baseTranslate = createTranslate(
-    messagesRef,
-    localeRef,
-    translatorOptions
-  );
-  const baseHasKey = createHasKey(
-    messagesRef,
-    localeRef,
-    translatorOptions
-  );
-  return {
-    // t (Scoped)
-    t: (key, replacements) => {
-      const fullKey = getFullKey(preKey, key);
-      return baseTranslate(fullKey, replacements);
-    },
-    // hasKey (Scoped)
-    hasKey: (key, locale) => {
-      const fullKey = getFullKey(preKey, key);
-      return baseHasKey(fullKey, locale);
+// src/translators/base-translator/base-translator.ts
+var BaseTranslator = class {
+  constructor(options) {
+    this.messagesRef = { current: {} };
+    this.localeRef = { current: "" };
+    /** Check if a key exists in the specified locale or current locale. */
+    this.hasKey = (key, targetLocale) => {
+      return hasKey({
+        messagesRef: this.messagesRef,
+        localeRef: this.localeRef,
+        key,
+        targetLocale
+      });
+    };
+    if (!options.messages) {
+      throw new Error("[intor-translator] 'messages' is required");
+    }
+    if (!options.locale) {
+      throw new Error("[intor-translator] 'locale' is required");
     }
-  };
+    this.options = options;
+    this.messagesRef.current = options.messages;
+    this.localeRef.current = options.locale;
+  }
+  /** Get all message data. */
+  get messages() {
+    return this.messagesRef.current;
+  }
+  /** Replace messages with new ones. */
+  setMessages(messages) {
+    this.messagesRef.current = messages;
+    clearMessageKeyCache();
+  }
+  /** Get the current active locale. */
+  get locale() {
+    return this.localeRef.current;
+  }
+  /** Change the active locale if available. */
+  setLocale(newLocale) {
+    if (newLocale in this.messagesRef.current) {
+      this.localeRef.current = newLocale;
+      return true;
+    }
+    return false;
+  }
 };
 
-// src/methods/scoped/create-scoped.ts
-var createScoped = (messagesRef, localeRef, translatorOptions) => {
-  return (preKey) => scoped({ messagesRef, localeRef, translatorOptions, preKey });
+// src/translators/core-translator/core-translator.ts
+var CoreTranslator = class extends BaseTranslator {
+  constructor(options) {
+    super(options);
+    this.isLoadingRef = { current: false };
+    this.t = (key, replacements) => {
+      return translate({
+        messagesRef: this.messagesRef,
+        localeRef: this.localeRef,
+        isLoadingRef: this.isLoadingRef,
+        translateConfig: this.options,
+        key,
+        replacements
+      });
+    };
+    this.options = options;
+  }
+  /** Get the current loading state. */
+  get isLoading() {
+    return this.isLoadingRef.current;
+  }
+  /** Set the loading state. */
+  setLoading(state) {
+    this.isLoadingRef.current = state;
+  }
 };
 
-// src/methods/set-locale/set-locale.ts
-var setLocale = ({
-  messagesRef,
-  localeRef,
-  newLocale
-}) => {
-  const messages = messagesRef.current;
-  if (newLocale in messages) {
-    localeRef.current = newLocale;
+// src/utils/get-full-key.ts
+var getFullKey = (preKey = "", key = "") => {
+  if (!preKey) {
+    return key;
+  }
+  if (!key) {
+    return preKey;
   }
+  return `${preKey}.${key}`;
 };
 
-// src/methods/set-locale/create-set-locale.ts
-var createSetLocale = (messagesRef, localeRef) => {
-  return (newLocale) => setLocale({ messagesRef, localeRef, newLocale });
+// src/translators/scope-translator/scope-translator.ts
+var ScopeTranslator = class extends CoreTranslator {
+  constructor(options) {
+    super(options);
+    this.scoped = (preKey) => {
+      return {
+        hasKey: (key, targetLocale) => {
+          const fullKey = getFullKey(preKey, key);
+          return hasKey({
+            messagesRef: this.messagesRef,
+            localeRef: this.localeRef,
+            key: fullKey,
+            targetLocale
+          });
+        },
+        t: (key, replacements) => {
+          const fullKey = getFullKey(preKey, key);
+          return translate({
+            messagesRef: this.messagesRef,
+            localeRef: this.localeRef,
+            isLoadingRef: this.isLoadingRef,
+            translateConfig: this.options,
+            key: fullKey,
+            replacements
+          });
+        }
+      };
+    };
+    this.options = options;
+  }
 };
 
-// src/create-translator.ts
-function createTranslator(translatorOptions) {
-  const { locale } = translatorOptions;
-  const messagesRef = { current: translatorOptions.messages };
-  const localeRef = { current: locale };
-  const getLocale2 = createGetLocale(localeRef);
-  const setLocale2 = createSetLocale(messagesRef, localeRef);
-  const getMessages2 = createGetMessages(messagesRef);
-  const hasKey2 = createHasKey(messagesRef, localeRef, translatorOptions);
-  const t = createTranslate(messagesRef, localeRef, translatorOptions);
-  const scoped2 = createScoped(messagesRef, localeRef, translatorOptions);
-  return {
-    getLocale: getLocale2,
-    setLocale: setLocale2,
-    getMessages: getMessages2,
-    hasKey: hasKey2,
-    t,
-    scoped: scoped2
-  };
-}
-
-exports.createTranslator = createTranslator;
+exports.Translator = ScopeTranslator;