@tolgee/core 5.8.0 → 5.8.2

package/src/Controller/State/State.ts

@@ -16,167 +16,150 @@ import {
 } from '../../helpers';
 import { initState, TolgeeOptions } from './initState';
 
-export const State = (
+export function State(
   onLanguageChange: EventEmitterInstance<string>,
   onPendingLanguageChange: EventEmitterInstance<string>,
   onRunningChange: EventEmitterInstance<boolean>
-) => {
+) {
   let state = initState();
   let devCredentials: DevCredentials = undefined;
 
-  function init(options?: Partial<TolgeeOptions>) {
-    state = initState(options, state);
-  }
-
-  function isRunning() {
-    return state.isRunning;
-  }
-
-  function setRunning(value: boolean) {
-    if (state.isRunning !== value) {
-      state.isRunning = value;
-      onRunningChange.emit(value);
-    }
-  }
-
-  function isInitialLoading() {
-    return state.isInitialLoading;
-  }
-
-  function setInitialLoading(value: boolean) {
-    state.isInitialLoading = value;
-  }
-
-  function getLanguage() {
-    return state.language || state.initialOptions.language;
-  }
-
-  function setLanguage(language: string) {
-    if (state.language !== language) {
-      state.language = language;
-      onLanguageChange.emit(language);
-    }
-  }
-
-  function getPendingLanguage() {
-    return state.pendingLanguage || getLanguage();
-  }
-
-  function setPendingLanguage(language: string) {
-    if (state.pendingLanguage !== language) {
-      state.pendingLanguage = language;
-      onPendingLanguageChange.emit(language);
-    }
-  }
-
-  function getInitialOptions() {
-    return { ...state.initialOptions, ...devCredentials };
-  }
-
-  function addActiveNs(ns: NsFallback) {
-    const namespaces = getFallbackArray(ns);
-    namespaces.forEach((namespace) => {
-      const value = state.activeNamespaces.get(namespace);
-      if (value !== undefined) {
-        state.activeNamespaces.set(namespace, value + 1);
-      } else {
-        state.activeNamespaces.set(namespace, 1);
+  const self = Object.freeze({
+    init(options?: Partial<TolgeeOptions>) {
+      state = initState(options, state);
+    },
+
+    isRunning() {
+      return state.isRunning;
+    },
+
+    setRunning(value: boolean) {
+      if (state.isRunning !== value) {
+        state.isRunning = value;
+        onRunningChange.emit(value);
       }
-    });
-  }
-
-  function removeActiveNs(ns: NsFallback) {
-    const namespaces = getFallbackArray(ns);
-    namespaces.forEach((namespace) => {
-      const value = state.activeNamespaces.get(namespace);
-      if (value !== undefined && value > 1) {
-        state.activeNamespaces.set(namespace, value - 1);
-      } else {
-        state.activeNamespaces.delete(namespace);
+    },
+
+    isInitialLoading() {
+      return state.isInitialLoading;
+    },
+
+    setInitialLoading(value: boolean) {
+      state.isInitialLoading = value;
+    },
+
+    getLanguage() {
+      return state.language || state.initialOptions.language;
+    },
+
+    setLanguage(language: string) {
+      if (state.language !== language) {
+        state.language = language;
+        onLanguageChange.emit(language);
       }
-    });
-  }
-
-  function getRequiredNamespaces() {
-    return unique([
-      ...(state.initialOptions.ns || [state.initialOptions.defaultNs]),
-      ...getFallbackArray(state.initialOptions.fallbackNs),
-      ...state.activeNamespaces.keys(),
-    ]);
-  }
-
-  function getFallbackLangs(lang?: string) {
-    const language = lang || getLanguage();
-    if (!language) {
-      return [];
-    }
-    return unique([
-      language,
-      ...getFallbackFromStruct(language, state.initialOptions.fallbackLanguage),
-    ]);
-  }
-
-  function getFallbackNs() {
-    return getFallbackArray(state.initialOptions.fallbackNs);
-  }
-
-  function getDefaultNs(ns?: NsType) {
-    return ns === undefined ? state.initialOptions.defaultNs : ns;
-  }
-
-  function getAvailableLanguages() {
-    if (state.initialOptions.availableLanguages) {
-      return state.initialOptions.availableLanguages;
-    } else if (state.initialOptions.staticData) {
-      const languagesFromStaticData = Object.keys(
-        state.initialOptions.staticData
-      ).map((key) => decodeCacheKey(key).language);
-      return Array.from(new Set(languagesFromStaticData));
-    }
-  }
-
-  function withDefaultNs(descriptor: CacheDescriptor): CacheDescriptorInternal {
-    return {
-      namespace:
-        descriptor.namespace === undefined
-          ? getInitialOptions().defaultNs
-          : descriptor.namespace,
-      language: descriptor.language,
-    };
-  }
-
-  function overrideCredentials(credentials: DevCredentials) {
-    if (credentials) {
-      devCredentials = {
-        ...credentials,
-        apiUrl: sanitizeUrl(credentials.apiUrl),
+    },
+
+    getPendingLanguage() {
+      return state.pendingLanguage || self.getLanguage();
+    },
+
+    setPendingLanguage(language: string) {
+      if (state.pendingLanguage !== language) {
+        state.pendingLanguage = language;
+        onPendingLanguageChange.emit(language);
+      }
+    },
+
+    getInitialOptions() {
+      return { ...state.initialOptions, ...devCredentials };
+    },
+
+    addActiveNs(ns: NsFallback) {
+      const namespaces = getFallbackArray(ns);
+      namespaces.forEach((namespace) => {
+        const value = state.activeNamespaces.get(namespace);
+        if (value !== undefined) {
+          state.activeNamespaces.set(namespace, value + 1);
+        } else {
+          state.activeNamespaces.set(namespace, 1);
+        }
+      });
+    },
+
+    removeActiveNs(ns: NsFallback) {
+      const namespaces = getFallbackArray(ns);
+      namespaces.forEach((namespace) => {
+        const value = state.activeNamespaces.get(namespace);
+        if (value !== undefined && value > 1) {
+          state.activeNamespaces.set(namespace, value - 1);
+        } else {
+          state.activeNamespaces.delete(namespace);
+        }
+      });
+    },
+    getRequiredNamespaces() {
+      return unique([
+        ...(state.initialOptions.ns || [state.initialOptions.defaultNs]),
+        ...getFallbackArray(state.initialOptions.fallbackNs),
+        ...state.activeNamespaces.keys(),
+      ]);
+    },
+
+    getFallbackLangs(lang?: string) {
+      const language = lang || self.getLanguage();
+      if (!language) {
+        return [];
+      }
+      return unique([
+        language,
+        ...getFallbackFromStruct(
+          language,
+          state.initialOptions.fallbackLanguage
+        ),
+      ]);
+    },
+
+    getFallbackNs() {
+      return getFallbackArray(state.initialOptions.fallbackNs);
+    },
+
+    getDefaultNs(ns?: NsType) {
+      return ns === undefined ? state.initialOptions.defaultNs : ns;
+    },
+
+    getAvailableLanguages() {
+      if (state.initialOptions.availableLanguages) {
+        return state.initialOptions.availableLanguages;
+      } else if (state.initialOptions.staticData) {
+        const languagesFromStaticData = Object.keys(
+          state.initialOptions.staticData
+        ).map((key) => decodeCacheKey(key).language);
+        return Array.from(new Set(languagesFromStaticData));
+      }
+    },
+
+    withDefaultNs(descriptor: CacheDescriptor): CacheDescriptorInternal {
+      return {
+        namespace:
+          descriptor.namespace === undefined
+            ? self.getInitialOptions().defaultNs
+            : descriptor.namespace,
+        language: descriptor.language,
       };
-    } else {
-      devCredentials = undefined;
-    }
-  }
-
-  return Object.freeze({
-    init,
-    isRunning,
-    setRunning,
-    isInitialLoading,
-    setInitialLoading,
-    getLanguage,
-    setLanguage,
-    getPendingLanguage,
-    setPendingLanguage,
-    getInitialOptions,
-    addActiveNs,
-    removeActiveNs,
-    getRequiredNamespaces,
-    getFallbackLangs,
-    getFallbackNs,
-    getDefaultNs,
-    getAvailableLanguages,
-    withDefaultNs,
-    overrideCredentials,
+    },
+
+    overrideCredentials(credentials: DevCredentials) {
+      if (credentials) {
+        devCredentials = {
+          ...credentials,
+          apiUrl: sanitizeUrl(credentials.apiUrl),
+        };
+      } else {
+        devCredentials = undefined;
+      }
+    },
   });
-};
+  return self;
+}
 
 export type StateInstance = ReturnType<typeof State>;

package/src/Controller/State/initState.ts

@@ -139,10 +139,10 @@ export const combineOptions = <T extends TolgeeOptions>(
   return result;
 };
 
-export const initState = (
+export function initState(
   options?: Partial<TolgeeOptions>,
   previousState?: State
-): State => {
+): State {
   const initialOptions = combineOptions(
     defaultValues,
     previousState?.initialOptions,
@@ -161,4 +161,4 @@ export const initState = (
     isInitialLoading: false,
     isRunning: false,
   };
-};
+}

package/src/Controller/ValueObserver.ts

@@ -4,19 +4,18 @@ export const ValueObserver = <T = any>(
   handler: (value: T) => void
 ): ValueObserverInstance<T> => {
   let previousValue: T = initialValue;
-  function init(value: T) {
-    previousValue = value;
-  }
-  function notify() {
-    const value = valueGetter();
-    if (previousValue !== value) {
-      handler(value);
-    }
-    previousValue = value;
-  }
+
   return Object.freeze({
-    init,
-    notify,
+    init(value: T) {
+      previousValue = value;
+    },
+    notify() {
+      const value = valueGetter();
+      if (previousValue !== value) {
+        handler(value);
+      }
+      previousValue = value;
+    },
   });
 };
 

package/src/TolgeeCore.ts

@@ -9,20 +9,20 @@ import {
   TranslationKey,
 } from './types';
 
-const createTolgee = (options: TolgeeOptions) => {
+function createTolgee(options: TolgeeOptions) {
   const controller = Controller({
     options,
   });
 
   // restarts tolgee while applying callback
-  const withRestart = (callback: () => void) => {
+  function withRestart(callback: () => void) {
     const wasRunning = controller.isRunning();
     wasRunning && controller.stop();
     callback();
     wasRunning && controller.run();
-  };
+  }
 
-  const tolgee = Object.freeze({
+  const self = Object.freeze({
     /**
      * Listen to tolgee events.
      */
@@ -201,7 +201,7 @@ const createTolgee = (options: TolgeeOptions) => {
      */
     addPlugin(plugin: TolgeePlugin | undefined) {
       if (plugin) {
-        withRestart(() => controller.addPlugin(tolgee, plugin));
+        withRestart(() => controller.addPlugin(self, plugin));
       }
     },
 
@@ -218,8 +218,8 @@ const createTolgee = (options: TolgeeOptions) => {
     },
   });
 
-  return tolgee;
-};
+  return self;
+}
 
 export type TolgeeInstance = Omit<ReturnType<typeof createTolgee>, 't'> & {
   // enabling generics (when inferred they are lost)

package/src/__test/cache.test.ts

@@ -3,13 +3,14 @@ import { TolgeeCore, TolgeeInstance } from '../TolgeeCore';
 import { TolgeePlugin, TreeTranslationsData } from '../types';
 import { resolvablePromise } from './testTools';
 
-const waitForInitialLoad = (tolgee: TolgeeInstance) =>
-  new Promise<void>((resolve) => {
+function waitForInitialLoad(tolgee: TolgeeInstance) {
+  return new Promise<void>((resolve) => {
     const { unsubscribe } = tolgee.on('initialLoad', () => {
       unsubscribe();
       resolve();
     });
   });
+}
 
 const DevToolsPlugin =
   (postfix = ''): TolgeePlugin =>

package/src/helpers.ts

@@ -8,19 +8,20 @@ export function isPromise(value: any) {
   return Boolean(value && typeof value.then === 'function');
 }
 
-export const valueOrPromise = <T, R>(
+export function valueOrPromise<T, R>(
   value: T | Promise<T>,
   callback: (value: T) => R
-) => {
+) {
   if (isPromise(value)) {
     return Promise.resolve(value).then(callback);
   } else {
     return callback(value as T);
   }
-};
+}
 
-export const missingOptionError = (option: string) =>
-  `Tolgee: You need to specify '${option}' option`;
+export function missingOptionError(option: string) {
+  return `Tolgee: You need to specify '${option}' option`;
+}
 
 export function isObject(item: any) {
   return typeof item === 'object' && !Array.isArray(item) && item !== null;