@tolgee/core 5.8.0 → 5.8.2

package/src/Controller/Cache/Cache.ts

@@ -28,7 +28,7 @@ type CacheRecord = {
 
 type StateCache = Map<string, CacheRecord>;
 
-export const Cache = (
+export function Cache(
   onCacheChange: EventEmitterInstance<CacheDescriptorWithKey>,
   backendGetRecord: BackendGetRecord,
   backendGetDevRecord: BackendGetDevRecord,
@@ -36,32 +36,12 @@ export const Cache = (
   isInitialLoading: () => boolean,
   fetchingObserver: ValueObserverInstance<boolean>,
   loadingObserver: ValueObserverInstance<boolean>
-) => {
+) {
   const asyncRequests: CacheAsyncRequests = new Map();
   const cache: StateCache = new Map();
   let staticData: NonNullable<TolgeeStaticData> = {};
   let version = 0;
 
-  function addStaticData(data: TolgeeStaticData | undefined) {
-    if (data) {
-      staticData = { ...staticData, ...data };
-      Object.entries(data).forEach(([key, value]) => {
-        if (typeof value !== 'function') {
-          const descriptor = decodeCacheKey(key);
-          const existing = cache.get(key);
-          if (!existing || existing.version === 0) {
-            addRecordInternal(descriptor, value, 0);
-          }
-        }
-      });
-    }
-  }
-
-  function invalidate() {
-    asyncRequests.clear();
-    version += 1;
-  }
-
   function addRecordInternal(
     descriptor: CacheDescriptorInternal,
     data: TreeTranslationsData,
@@ -75,109 +55,6 @@ export const Cache = (
     onCacheChange.emit(descriptor);
   }
 
-  function addRecord(
-    descriptor: CacheDescriptorInternal,
-    data: TreeTranslationsData
-  ) {
-    addRecordInternal(descriptor, data, version);
-  }
-
-  function exists(descriptor: CacheDescriptorInternal, strict = false) {
-    const record = cache.get(encodeCacheKey(descriptor));
-    if (record && strict) {
-      return record.version === version;
-    }
-    return Boolean(record);
-  }
-
-  function getRecord(descriptor: CacheDescriptor) {
-    return cache.get(encodeCacheKey(withDefaultNs(descriptor)))?.data;
-  }
-
-  function getTranslation(descriptor: CacheDescriptorInternal, key: string) {
-    return cache.get(encodeCacheKey(descriptor))?.data.get(key);
-  }
-
-  function getTranslationNs(
-    namespaces: string[],
-    languages: string[],
-    key: string
-  ) {
-    for (const namespace of namespaces) {
-      for (const language of languages) {
-        const value = cache
-          .get(encodeCacheKey({ language, namespace }))
-          ?.data.get(key);
-        if (value !== undefined && value !== null) {
-          return [namespace];
-        }
-      }
-    }
-    return unique(namespaces);
-  }
-
-  function getTranslationFallback(
-    namespaces: string[],
-    languages: string[],
-    key: string
-  ) {
-    for (const namespace of namespaces) {
-      for (const language of languages) {
-        const value = cache
-          .get(encodeCacheKey({ language, namespace }))
-          ?.data.get(key);
-        if (value !== undefined && value !== null) {
-          return value;
-        }
-      }
-    }
-    return undefined;
-  }
-
-  function changeTranslation(
-    descriptor: CacheDescriptorInternal,
-    key: string,
-    value: TranslationValue
-  ) {
-    const record = cache.get(encodeCacheKey(descriptor))?.data;
-    record?.set(key, value);
-    onCacheChange.emit({ ...descriptor, key });
-  }
-
-  function isFetching(ns?: NsFallback) {
-    if (isInitialLoading()) {
-      return true;
-    }
-
-    if (ns === undefined) {
-      return asyncRequests.size > 0;
-    }
-    const namespaces = getFallbackArray(ns);
-    return Boolean(
-      Array.from(asyncRequests.keys()).find((key) =>
-        namespaces.includes(decodeCacheKey(key).namespace)
-      )
-    );
-  }
-
-  function isLoading(language: string | undefined, ns?: NsFallback) {
-    const namespaces = getFallbackArray(ns);
-
-    return Boolean(
-      isInitialLoading() ||
-        Array.from(asyncRequests.keys()).find((key) => {
-          const descriptor = decodeCacheKey(key);
-          return (
-            (!namespaces.length || namespaces.includes(descriptor.namespace)) &&
-            !exists({
-              namespace: descriptor.namespace,
-              language: language!,
-            })
-          );
-        })
-    );
-  }
-
   /**
    * Fetches production data
    */
@@ -219,82 +96,187 @@ export const Cache = (
     return dataPromise;
   }
 
-  async function loadRecords(descriptors: CacheDescriptor[], isDev: boolean) {
-    const withPromises = descriptors.map((descriptor) => {
-      const keyObject = withDefaultNs(descriptor);
-      const cacheKey = encodeCacheKey(keyObject);
-      const existingPromise = asyncRequests.get(cacheKey);
+  const self = Object.freeze({
+    addStaticData(data: TolgeeStaticData | undefined) {
+      if (data) {
+        staticData = { ...staticData, ...data };
+        Object.entries(data).forEach(([key, value]) => {
+          if (typeof value !== 'function') {
+            const descriptor = decodeCacheKey(key);
+            const existing = cache.get(key);
+            if (!existing || existing.version === 0) {
+              addRecordInternal(descriptor, value, 0);
+            }
+          }
+        });
+      }
+    },
+
+    invalidate() {
+      asyncRequests.clear();
+      version += 1;
+    },
+
+    addRecord(descriptor: CacheDescriptorInternal, data: TreeTranslationsData) {
+      addRecordInternal(descriptor, data, version);
+    },
+
+    exists(descriptor: CacheDescriptorInternal, strict = false) {
+      const record = cache.get(encodeCacheKey(descriptor));
+      if (record && strict) {
+        return record.version === version;
+      }
+      return Boolean(record);
+    },
+
+    getRecord(descriptor: CacheDescriptor) {
+      return cache.get(encodeCacheKey(withDefaultNs(descriptor)))?.data;
+    },
+
+    getTranslation(descriptor: CacheDescriptorInternal, key: string) {
+      return cache.get(encodeCacheKey(descriptor))?.data.get(key);
+    },
+
+    getTranslationNs(namespaces: string[], languages: string[], key: string) {
+      for (const namespace of namespaces) {
+        for (const language of languages) {
+          const value = cache
+            .get(encodeCacheKey({ language, namespace }))
+            ?.data.get(key);
+          if (value !== undefined && value !== null) {
+            return [namespace];
+          }
+        }
+      }
+      return unique(namespaces);
+    },
+
+    getTranslationFallback(
+      namespaces: string[],
+      languages: string[],
+      key: string
+    ) {
+      for (const namespace of namespaces) {
+        for (const language of languages) {
+          const value = cache
+            .get(encodeCacheKey({ language, namespace }))
+            ?.data.get(key);
+          if (value !== undefined && value !== null) {
+            return value;
+          }
+        }
+      }
+      return undefined;
+    },
+
+    changeTranslation(
+      descriptor: CacheDescriptorInternal,
+      key: string,
+      value: TranslationValue
+    ) {
+      const record = cache.get(encodeCacheKey(descriptor))?.data;
+      record?.set(key, value);
+      onCacheChange.emit({ ...descriptor, key });
+    },
+
+    isFetching(ns?: NsFallback) {
+      if (isInitialLoading()) {
+        return true;
+      }
 
-      if (existingPromise) {
+      if (ns === undefined) {
+        return asyncRequests.size > 0;
+      }
+      const namespaces = getFallbackArray(ns);
+      return Boolean(
+        Array.from(asyncRequests.keys()).find((key) =>
+          namespaces.includes(decodeCacheKey(key).namespace)
+        )
+      );
+    },
+
+    isLoading(language: string | undefined, ns?: NsFallback) {
+      const namespaces = getFallbackArray(ns);
+
+      return Boolean(
+        isInitialLoading() ||
+          Array.from(asyncRequests.keys()).find((key) => {
+            const descriptor = decodeCacheKey(key);
+            return (
+              (!namespaces.length ||
+                namespaces.includes(descriptor.namespace)) &&
+              !self.exists({
+                namespace: descriptor.namespace,
+                language: language!,
+              })
+            );
+          })
+      );
+    },
+
+    async loadRecords(descriptors: CacheDescriptor[], isDev: boolean) {
+      const withPromises = descriptors.map((descriptor) => {
+        const keyObject = withDefaultNs(descriptor);
+        const cacheKey = encodeCacheKey(keyObject);
+        const existingPromise = asyncRequests.get(cacheKey);
+
+        if (existingPromise) {
+          return {
+            new: false,
+            promise: existingPromise,
+            keyObject,
+            cacheKey,
+          };
+        }
+        const dataPromise =
+          fetchData(keyObject, isDev) || Promise.resolve(undefined);
+        asyncRequests.set(cacheKey, dataPromise);
         return {
-          new: false,
-          promise: existingPromise,
+          new: true,
+          promise: dataPromise,
           keyObject,
           cacheKey,
         };
-      }
-      const dataPromise =
-        fetchData(keyObject, isDev) || Promise.resolve(undefined);
-      asyncRequests.set(cacheKey, dataPromise);
-      return {
-        new: true,
-        promise: dataPromise,
-        keyObject,
-        cacheKey,
-      };
-    });
-    fetchingObserver.notify();
-    loadingObserver.notify();
-
-    const results = await Promise.all(withPromises.map((val) => val.promise));
-
-    withPromises.forEach((value, i) => {
-      const promiseChanged =
-        asyncRequests.get(value.cacheKey) !== value.promise;
-      // if promise has changed in between, it means cache been invalidated or
-      // new data are being fetched
-      if (value.new && !promiseChanged) {
-        asyncRequests.delete(value.cacheKey);
-        const data = results[i];
-        if (data) {
-          addRecord(value.keyObject, data);
-        } else if (!getRecord(value.keyObject)) {
-          // if no data exist, put empty object
-          addRecord(value.keyObject, {});
+      });
+      fetchingObserver.notify();
+      loadingObserver.notify();
+
+      const results = await Promise.all(withPromises.map((val) => val.promise));
+
+      withPromises.forEach((value, i) => {
+        const promiseChanged =
+          asyncRequests.get(value.cacheKey) !== value.promise;
+        // if promise has changed in between, it means cache been invalidated or
+        // new data are being fetched
+        if (value.new && !promiseChanged) {
+          asyncRequests.delete(value.cacheKey);
+          const data = results[i];
+          if (data) {
+            self.addRecord(value.keyObject, data);
+          } else if (!self.getRecord(value.keyObject)) {
+            // if no data exist, put empty object
+            self.addRecord(value.keyObject, {});
+          }
         }
-      }
-    });
-    fetchingObserver.notify();
-    loadingObserver.notify();
-
-    return withPromises.map((val) => getRecord(val.keyObject)!);
-  }
+      });
+      fetchingObserver.notify();
+      loadingObserver.notify();
 
-  function getAllRecords() {
-    const entries = Array.from(cache.entries());
-    return entries.map(([key, entry]) => {
-      return {
-        ...decodeCacheKey(key),
-        data: entry.data,
-      };
-    });
-  }
+      return withPromises.map((val) => self.getRecord(val.keyObject)!);
+    },
 
-  return Object.freeze({
-    addStaticData,
-    invalidate,
-    addRecord,
-    exists,
-    getRecord,
-    getTranslation,
-    getTranslationNs,
-    getTranslationFallback,
-    changeTranslation,
-    isFetching,
-    isLoading,
-    loadRecords,
-    getAllRecords,
+    getAllRecords() {
+      const entries = Array.from(cache.entries());
+      return entries.map(([key, entry]) => {
+        return {
+          ...decodeCacheKey(key),
+          data: entry.data,
+        };
+      });
+    },
   });
-};
+
+  return self;
+}
 
 export type CacheInstance = ReturnType<typeof Cache>;

package/src/Controller/Controller.ts

@@ -19,7 +19,7 @@ type StateServiceProps = {
   options?: Partial<TolgeeOptions>;
 };
 
-export const Controller = ({ options }: StateServiceProps) => {
+export function Controller({ options }: StateServiceProps) {
   const events = Events(getFallbackNs, getDefaultNs);
   const fetchingObserver = ValueObserver<boolean>(
     false,
@@ -28,7 +28,7 @@ export const Controller = ({ options }: StateServiceProps) => {
   );
   const loadingObserver = ValueObserver<boolean>(
     false,
-    () => isLoading(),
+    () => self.isLoading(),
     events.onLoadingChange.emit
   );
 
@@ -99,7 +99,7 @@ export const Controller = ({ options }: StateServiceProps) => {
     const previousValue = cache.getTranslation(keyObject, key);
     cache.changeTranslation(keyObject, key, value);
     return {
-      revert: () => {
+      revert() {
         cache.changeTranslation(keyObject, key, previousValue);
       },
     };
@@ -110,25 +110,6 @@ export const Controller = ({ options }: StateServiceProps) => {
     cache.addStaticData(state.getInitialOptions().staticData);
   }
 
-  function isLoading(ns?: NsFallback) {
-    return cache.isLoading(state.getLanguage()!, ns);
-  }
-
-  function isDev() {
-    return Boolean(
-      state.getInitialOptions().apiKey && state.getInitialOptions().apiUrl
-    );
-  }
-
-  async function addActiveNs(ns: NsFallback, forget?: boolean) {
-    if (!forget) {
-      state.addActiveNs(ns);
-    }
-    if (state.isRunning()) {
-      await loadRequiredRecords(undefined, ns);
-    }
-  }
-
   function getRequiredRecords(lang?: string, ns?: NsFallback) {
     const languages = state.getFallbackLangs(lang);
     const namespaces = getRequiredNamespaces(ns);
@@ -143,49 +124,10 @@ export const Controller = ({ options }: StateServiceProps) => {
     return result;
   }
 
-  function isLoaded(ns?: NsFallback) {
-    const language = state.getLanguage();
-    if (!language) {
-      return false;
-    }
-    const languages = state.getFallbackLangs(language);
-    const namespaces = getRequiredNamespaces(ns);
-    const result: CacheDescriptor[] = [];
-    languages.forEach((language) => {
-      namespaces.forEach((namespace) => {
-        if (!cache.exists({ language, namespace })) {
-          result.push({ language, namespace });
-        }
-      });
-    });
-    return result.length === 0;
-  }
-
   function loadRequiredRecords(lang?: string, ns?: NsFallback) {
     const descriptors = getRequiredRecords(lang, ns);
     if (descriptors.length) {
-      return valueOrPromise(loadRecords(descriptors), () => {});
-    }
-  }
-
-  async function changeLanguage(language: string) {
-    if (
-      state.getPendingLanguage() === language &&
-      state.getLanguage() === language
-    ) {
-      return;
-    }
-    state.setPendingLanguage(language);
-
-    if (state.isRunning()) {
-      await loadRequiredRecords(language);
-    }
-
-    if (language === state.getPendingLanguage()) {
-      // there might be parallel language change
-      // we only want to apply latest
-      state.setLanguage(language);
-      pluginService.setStoredLanguage(language);
+      return valueOrPromise(self.loadRecords(descriptors), () => {});
     }
   }
 
@@ -239,15 +181,7 @@ export const Controller = ({ options }: StateServiceProps) => {
     });
   }
 
-  async function loadRecord(descriptor: CacheDescriptor) {
-    return (await loadRecords([descriptor]))[0];
-  }
-
-  function loadRecords(descriptors: CacheDescriptor[]) {
-    return cache.loadRecords(descriptors, isDev());
-  }
-
-  const checkCorrectConfiguration = () => {
+  function checkCorrectConfiguration() {
     const languageComputable =
       pluginService.getLanguageDetector() || pluginService.getLanguageStorage();
     if (languageComputable) {
@@ -263,55 +197,112 @@ export const Controller = ({ options }: StateServiceProps) => {
         throw new Error(missingOptionError('language'));
       }
     }
-  };
-
-  function run() {
-    let result: Promise<void> | undefined = undefined;
-    checkCorrectConfiguration();
-    if (!state.isRunning()) {
-      if (isDev()) {
-        cache.invalidate();
-      }
-      state.setRunning(true);
-      pluginService.run();
-      result = loadInitial();
-    }
-    return Promise.resolve(result);
-  }
-
-  function stop() {
-    if (state.isRunning()) {
-      pluginService.stop();
-      state.setRunning(false);
-    }
   }
 
-  const t: TFnType = (...args) => {
-    // @ts-ignore
-    const params = getTranslateProps(...args);
-    const translation = getTranslation(params);
-    return pluginService.formatTranslation({ ...params, translation });
-  };
-
-  return Object.freeze({
+  const self = Object.freeze({
     ...events,
     ...state,
     ...pluginService,
     ...cache,
-    init,
-    changeLanguage,
-    getTranslation,
-    changeTranslation,
-    addActiveNs,
-    loadRecords,
-    loadRecord,
-    isLoading,
-    isLoaded,
-    t,
-    isDev,
-    run,
-    stop,
+    init: init,
+    getTranslation: getTranslation,
+    changeTranslation: changeTranslation,
+    async changeLanguage(language: string) {
+      if (
+        state.getPendingLanguage() === language &&
+        state.getLanguage() === language
+      ) {
+        return;
+      }
+      state.setPendingLanguage(language);
+
+      if (state.isRunning()) {
+        await loadRequiredRecords(language);
+      }
+
+      if (language === state.getPendingLanguage()) {
+        // there might be parallel language change
+        // we only want to apply latest
+        state.setLanguage(language);
+        pluginService.setStoredLanguage(language);
+      }
+    },
+
+    async addActiveNs(ns: NsFallback, forget?: boolean) {
+      if (!forget) {
+        state.addActiveNs(ns);
+      }
+      if (state.isRunning()) {
+        await loadRequiredRecords(undefined, ns);
+      }
+    },
+
+    loadRecords(descriptors: CacheDescriptor[]) {
+      return cache.loadRecords(descriptors, self.isDev());
+    },
+
+    async loadRecord(descriptor: CacheDescriptor) {
+      return (await self.loadRecords([descriptor]))[0];
+    },
+
+    isLoading(ns?: NsFallback) {
+      return cache.isLoading(state.getLanguage()!, ns);
+    },
+
+    isLoaded(ns?: NsFallback) {
+      const language = state.getLanguage();
+      if (!language) {
+        return false;
+      }
+      const languages = state.getFallbackLangs(language);
+      const namespaces = getRequiredNamespaces(ns);
+      const result: CacheDescriptor[] = [];
+      languages.forEach((language) => {
+        namespaces.forEach((namespace) => {
+          if (!cache.exists({ language, namespace })) {
+            result.push({ language, namespace });
+          }
+        });
+      });
+      return result.length === 0;
+    },
+
+    t: ((...args: Parameters<TFnType>) => {
+      // @ts-ignore
+      const params = getTranslateProps(...args);
+      const translation = getTranslation(params);
+      return pluginService.formatTranslation({ ...params, translation });
+    }) as TFnType,
+
+    isDev() {
+      return Boolean(
+        state.getInitialOptions().apiKey && state.getInitialOptions().apiUrl
+      );
+    },
+
+    run() {
+      let result: Promise<void> | undefined = undefined;
+      checkCorrectConfiguration();
+      if (!state.isRunning()) {
+        if (self.isDev()) {
+          cache.invalidate();
+        }
+        state.setRunning(true);
+        pluginService.run();
+        result = loadInitial();
+      }
+      return Promise.resolve(result);
+    },
+
+    stop() {
+      if (state.isRunning()) {
+        pluginService.stop();
+        state.setRunning(false);
+      }
+    },
   });
-};
+
+  return self;
+}
 
 export type ControllerInstance = ReturnType<typeof Controller>;