@tolgee/core 5.8.0 → 5.8.2

package/src/Controller/Plugins/Plugins.ts

@@ -25,14 +25,14 @@ import {
 } from '../../types';
 import { DEFAULT_FORMAT_ERROR } from '../State/initState';
 
-export const Plugins = (
+export function Plugins(
   getLanguage: () => string | undefined,
   getInitialOptions: () => TolgeeOptionsInternal,
   getAvailableLanguages: () => string[] | undefined,
   getTranslationNs: (props: KeyAndNamespacesInternal) => string[],
   getTranslation: (props: KeyAndNamespacesInternal) => string | undefined,
   changeTranslation: ChangeTranslationInterface
-) => {
+) {
   const plugins = {
     ui: undefined as UiMiddleware | undefined,
   };
@@ -65,80 +65,59 @@ export const Plugins = (
     instances.ui?.handleElementClick(withNs, event);
   };
 
-  const stop = () => {
-    instances.ui = undefined;
-    instances.observer?.stop();
-  };
-
-  const highlight: HighlightInterface = (key, ns) => {
-    return instances.observer?.highlight?.(key, ns) || { unhighlight() {} };
-  };
-
   const findPositions: FindPositionsInterface = (key, ns) => {
     return instances.observer?.findPositions(key, ns) || [];
   };
 
-  const translate = (props: TranslatePropsInternal) => {
+  function translate(props: TranslatePropsInternal) {
     const translation = getTranslation({
       key: props.key,
       ns: props.ns,
     });
-    return formatTranslation({ ...props, translation, formatEnabled: true });
-  };
+    return self.formatTranslation({
+      ...props,
+      translation,
+      formatEnabled: true,
+    });
+  }
 
-  const setObserver = (observer: ObserverMiddleware | undefined) => {
+  function setObserver(observer: ObserverMiddleware | undefined) {
     instances.observer = observer?.();
-  };
+  }
 
-  const hasObserver = () => {
+  function hasObserver() {
     return Boolean(instances.observer);
-  };
+  }
 
-  const addFormatter = (formatter: FormatterMiddleware | undefined) => {
+  function addFormatter(formatter: FormatterMiddleware | undefined) {
     if (formatter) {
       instances.formatters.push(formatter);
     }
-  };
+  }
 
-  const setFinalFormatter = (
-    formatter: FinalFormatterMiddleware | undefined
-  ) => {
+  function setFinalFormatter(formatter: FinalFormatterMiddleware | undefined) {
     instances.finalFormatter = formatter;
-  };
+  }
 
-  const setUi = (ui: UiMiddleware | undefined) => {
+  function setUi(ui: UiMiddleware | undefined) {
     plugins.ui = ui as UiMiddleware;
-  };
+  }
 
-  const hasUi = () => {
+  function hasUi() {
     return Boolean(plugins.ui);
-  };
+  }
 
-  const setLanguageStorage = (
-    storage: LanguageStorageMiddleware | undefined
-  ) => {
+  function setLanguageStorage(storage: LanguageStorageMiddleware | undefined) {
     instances.languageStorage = storage;
-  };
-
-  const getLanguageStorage = () => {
-    return instances.languageStorage;
-  };
-
-  const setStoredLanguage = (language: string) => {
-    instances.languageStorage?.setLanguage(language);
-  };
+  }
 
-  const setLanguageDetector = (
+  function setLanguageDetector(
     detector: LanguageDetectorMiddleware | undefined
-  ) => {
+  ) {
     instances.languageDetector = detector;
-  };
-
-  const getLanguageDetector = () => {
-    return instances.languageDetector;
-  };
+  }
 
-  const detectLanguage = () => {
+  function detectLanguage() {
     if (!instances.languageDetector) {
       return undefined;
     }
@@ -148,94 +127,17 @@ export const Plugins = (
     return instances.languageDetector.getLanguage({
       availableLanguages,
     });
-  };
-
-  const getInitialLanguage = () => {
-    const availableLanguages = getAvailableLanguages();
-    const languageOrPromise = instances.languageStorage?.getLanguage();
-
-    return valueOrPromise(languageOrPromise, (language) => {
-      if (
-        (!availableLanguages || availableLanguages.includes(language!)) &&
-        language
-      ) {
-        return language;
-      }
-      return detectLanguage();
-    });
-  };
+  }
 
-  const addBackend = (backend: BackendMiddleware | undefined) => {
+  function addBackend(backend: BackendMiddleware | undefined) {
     if (backend) {
       instances.backends.push(backend);
     }
-  };
+  }
 
-  const setDevBackend = (backend: BackendDevMiddleware | undefined) => {
+  function setDevBackend(backend: BackendDevMiddleware | undefined) {
     instances.devBackend = backend;
-  };
-
-  const run = () => {
-    const { apiKey, apiUrl, projectId, observerOptions } = getInitialOptions();
-    instances.ui = plugins.ui?.({
-      apiKey: apiKey!,
-      apiUrl: apiUrl!,
-      projectId,
-      highlight,
-      changeTranslation,
-      findPositions,
-    });
-
-    instances.observer?.run({
-      mouseHighlight: true,
-      options: observerOptions,
-      translate,
-      onClick,
-    });
-  };
-
-  const getDevBackend = () => {
-    return instances.devBackend;
-  };
-
-  const getBackendDevRecord: BackendGetRecord = ({ language, namespace }) => {
-    const { apiKey, apiUrl, projectId } = getInitialOptions();
-    return instances.devBackend?.getRecord({
-      apiKey,
-      apiUrl,
-      projectId,
-      language,
-      namespace,
-    });
-  };
-
-  const getBackendRecord: BackendGetRecord = ({ language, namespace }) => {
-    for (const backend of instances.backends) {
-      const data = backend.getRecord({ language, namespace });
-      if (isPromise(data)) {
-        return data?.catch((e) => {
-          // eslint-disable-next-line no-console
-          console.error(e);
-          return {};
-        });
-      }
-      if (data !== undefined) {
-        return data;
-      }
-    }
-    return undefined;
-  };
-
-  const unwrap = (text: string): Unwrapped => {
-    if (instances.observer) {
-      return instances.observer?.unwrap(text);
-    }
-    return { text, keys: [] };
-  };
-
-  const retranslate = () => {
-    instances.observer?.retranslate();
-  };
+  }
 
   function addPlugin(tolgeeInstance: TolgeeInstance, plugin: TolgeePlugin) {
     const pluginTools = Object.freeze({
@@ -253,104 +155,189 @@ export const Plugins = (
     plugin(tolgeeInstance, pluginTools);
   }
 
-  function formatTranslation({
-    formatEnabled,
-    ...props
-  }: TranslatePropsInternal & { formatEnabled?: boolean }) {
-    const { key, translation, defaultValue, noWrap, params, orEmpty, ns } =
-      props;
-    const formattableTranslation = translation || defaultValue;
-    let result = formattableTranslation || (orEmpty ? '' : key);
-
-    const language = getLanguage();
-    const isFormatEnabled =
-      formatEnabled || !instances.observer?.outputNotFormattable;
-
-    const wrap = (result: string) => {
-      if (instances.observer && !noWrap) {
-        return instances.observer.wrap({
-          key,
-          translation: result,
-          defaultValue,
-          params,
-          ns,
-        });
+  const self = Object.freeze({
+    addPlugin,
+
+    run() {
+      const { apiKey, apiUrl, projectId, observerOptions } =
+        getInitialOptions();
+      instances.ui = plugins.ui?.({
+        apiKey: apiKey!,
+        apiUrl: apiUrl!,
+        projectId,
+        highlight: self.highlight,
+        changeTranslation,
+        findPositions,
+      });
+
+      instances.observer?.run({
+        mouseHighlight: true,
+        options: observerOptions,
+        translate,
+        onClick,
+      });
+    },
+
+    stop() {
+      instances.ui = undefined;
+      instances.observer?.stop();
+    },
+
+    getLanguageStorage() {
+      return instances.languageStorage;
+    },
+
+    getInitialLanguage() {
+      const availableLanguages = getAvailableLanguages();
+      const languageOrPromise = instances.languageStorage?.getLanguage();
+
+      return valueOrPromise(languageOrPromise, (language) => {
+        if (
+          (!availableLanguages || availableLanguages.includes(language!)) &&
+          language
+        ) {
+          return language;
+        }
+        return detectLanguage();
+      });
+    },
+
+    setStoredLanguage(language: string) {
+      instances.languageStorage?.setLanguage(language);
+    },
+
+    getDevBackend() {
+      return instances.devBackend;
+    },
+
+    getBackendRecord: (({ language, namespace }) => {
+      for (const backend of instances.backends) {
+        const data = backend.getRecord({ language, namespace });
+        if (isPromise(data)) {
+          return data?.catch((e) => {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            return {};
+          });
+        }
+        if (data !== undefined) {
+          return data;
+        }
       }
-      return result;
-    };
+      return undefined;
+    }) as BackendGetRecord,
+
+    getBackendDevRecord: (({ language, namespace }) => {
+      const { apiKey, apiUrl, projectId } = getInitialOptions();
+      return instances.devBackend?.getRecord({
+        apiKey,
+        apiUrl,
+        projectId,
+        language,
+        namespace,
+      });
+    }) as BackendGetRecord,
+
+    getLanguageDetector() {
+      return instances.languageDetector;
+    },
+
+    retranslate() {
+      instances.observer?.retranslate();
+    },
+
+    highlight: ((key, ns) => {
+      return instances.observer?.highlight?.(key, ns) || { unhighlight() {} };
+    }) as HighlightInterface,
+
+    unwrap(text: string): Unwrapped {
+      if (instances.observer) {
+        return instances.observer?.unwrap(text);
+      }
+      return { text, keys: [] };
+    },
 
-    result = wrap(result);
-    try {
-      if (formattableTranslation && language && isFormatEnabled) {
-        for (const formatter of instances.formatters) {
-          result = formatter.format({
+    wrap(params: WrapperWrapProps) {
+      if (instances.observer) {
+        return instances.observer?.wrap(params);
+      }
+      return params.translation;
+    },
+
+    hasDevBackend() {
+      return Boolean(self.getDevBackend());
+    },
+
+    formatTranslation({
+      formatEnabled,
+      ...props
+    }: TranslatePropsInternal & { formatEnabled?: boolean }) {
+      const { key, translation, defaultValue, noWrap, params, orEmpty, ns } =
+        props;
+      const formattableTranslation = translation || defaultValue;
+      let result = formattableTranslation || (orEmpty ? '' : key);
+
+      const language = getLanguage();
+      const isFormatEnabled =
+        formatEnabled || !instances.observer?.outputNotFormattable;
+
+      const wrap = (result: string) => {
+        if (instances.observer && !noWrap) {
+          return instances.observer.wrap({
+            key,
+            translation: result,
+            defaultValue,
+            params,
+            ns,
+          });
+        }
+        return result;
+      };
+
+      result = wrap(result);
+      try {
+        if (formattableTranslation && language && isFormatEnabled) {
+          for (const formatter of instances.formatters) {
+            result = formatter.format({
+              translation: result,
+              language,
+              params,
+            });
+          }
+        }
+        if (
+          instances.finalFormatter &&
+          formattableTranslation &&
+          language &&
+          isFormatEnabled
+        ) {
+          result = instances.finalFormatter.format({
             translation: result,
             language,
             params,
           });
         }
+      } catch (e: any) {
+        // eslint-disable-next-line no-console
+        console.error(e);
+        const errorMessage = getErrorMessage(e) || DEFAULT_FORMAT_ERROR;
+        const onFormatError = getInitialOptions().onFormatError;
+        const formatErrorType = typeof onFormatError;
+        if (formatErrorType === 'string') {
+          result = onFormatError as string;
+        } else if (formatErrorType === 'function') {
+          result = (onFormatError as FormatErrorHandler)(errorMessage, props);
+        } else {
+          result = DEFAULT_FORMAT_ERROR;
+        }
+        // wrap error message, so it's detectable
+        result = wrap(result);
       }
-      if (
-        instances.finalFormatter &&
-        formattableTranslation &&
-        language &&
-        isFormatEnabled
-      ) {
-        result = instances.finalFormatter.format({
-          translation: result,
-          language,
-          params,
-        });
-      }
-    } catch (e: any) {
-      // eslint-disable-next-line no-console
-      console.error(e);
-      const errorMessage = getErrorMessage(e) || DEFAULT_FORMAT_ERROR;
-      const onFormatError = getInitialOptions().onFormatError;
-      const formatErrorType = typeof onFormatError;
-      if (formatErrorType === 'string') {
-        result = onFormatError as string;
-      } else if (formatErrorType === 'function') {
-        result = (onFormatError as FormatErrorHandler)(errorMessage, props);
-      } else {
-        result = DEFAULT_FORMAT_ERROR;
-      }
-      // wrap error message, so it's detectable
-      result = wrap(result);
-    }
-
-    return result;
-  }
-
-  function hasDevBackend() {
-    return Boolean(getDevBackend());
-  }
 
-  const wrap = (params: WrapperWrapProps) => {
-    if (instances.observer) {
-      return instances.observer?.wrap(params);
-    }
-    return params.translation;
-  };
-
-  return Object.freeze({
-    addPlugin,
-    formatTranslation,
-    getDevBackend,
-    getBackendRecord,
-    getBackendDevRecord,
-    getLanguageDetector,
-    getLanguageStorage,
-    getInitialLanguage,
-    setStoredLanguage,
-    run,
-    stop,
-    retranslate,
-    highlight,
-    unwrap,
-    wrap,
-    hasDevBackend,
+      return result;
+    },
   });
-};
+  return self;
+}
 
 export type PluginsInstance = ReturnType<typeof Plugins>;