@tolgee/core 5.8.0 → 5.8.2

package/src/Controller/Events/EventEmitter.ts

@@ -1,32 +1,31 @@
 import { Subscription, Listener } from '../../types';
 
-export const EventEmitter = <T>(
+export function EventEmitter<T>(
   isActive: () => boolean
-): EventEmitterInstance<T> => {
+): EventEmitterInstance<T> {
   let handlers: Listener<T>[] = [];
 
-  const listen = (handler: Listener<T>): Subscription => {
-    const handlerWrapper: Listener<T> = (e) => {
-      handler(e);
-    };
+  return Object.freeze({
+    listen(handler: Listener<T>): Subscription {
+      const handlerWrapper: Listener<T> = (e) => {
+        handler(e);
+      };
 
-    handlers.push(handlerWrapper);
+      handlers.push(handlerWrapper);
 
-    return {
-      unsubscribe: () => {
-        handlers = handlers.filter((i) => handlerWrapper !== i);
-      },
-    };
-  };
-
-  const emit = (data: T) => {
-    if (isActive()) {
-      handlers.forEach((handler) => handler({ value: data }));
-    }
-  };
-
-  return Object.freeze({ listen, emit });
-};
+      return {
+        unsubscribe() {
+          handlers = handlers.filter((i) => handlerWrapper !== i);
+        },
+      };
+    },
+    emit(data: T) {
+      if (isActive()) {
+        handlers.forEach((handler) => handler({ value: data }));
+      }
+    },
+  });
+}
 
 export type EventEmitterInstance<T> = {
   readonly listen: (handler: Listener<T>) => Subscription;

package/src/Controller/Events/EventEmitterSelective.ts

@@ -15,54 +15,15 @@ type HandlerWrapperType = {
   namespaces: Set<string>;
 };
 
-export const EventEmitterSelective = (
+export function EventEmitterSelective(
   isActive: () => boolean,
   getFallbackNs: () => string[],
   getDefaultNs: () => string
-): EventEmitterSelectiveInstance => {
+): EventEmitterSelectiveInstance {
   const listeners: Set<Listener<undefined>> = new Set();
   const partialListeners: Set<HandlerWrapperType> = new Set();
 
-  const listen = (handler: Listener<undefined>) => {
-    listeners.add(handler);
-    const result = {
-      unsubscribe: () => {
-        listeners.delete(handler);
-      },
-    };
-    return result;
-  };
-
-  const listenSome = (handler: Listener<undefined>) => {
-    const handlerWrapper = {
-      fn: (e: ListenerEvent<undefined>) => {
-        handler(e);
-      },
-      namespaces: new Set<NsListType>(),
-    };
-
-    partialListeners.add(handlerWrapper);
-
-    const result = {
-      unsubscribe: () => {
-        partialListeners.delete(handlerWrapper);
-      },
-      subscribeNs: (ns: NsFallback) => {
-        getFallbackArray(ns).forEach((val) =>
-          handlerWrapper.namespaces.add(val)
-        );
-        if (ns === undefined) {
-          // subscribing to default ns
-          handlerWrapper.namespaces.add(getDefaultNs());
-        }
-        return result;
-      },
-    };
-
-    return result;
-  };
-
-  const callHandlers = (ns: Array<string> | undefined) => {
+  function callHandlers(ns: Array<string> | undefined) {
     // everything is implicitly subscribed to fallbacks
     // as it can always fall through to it
     const fallbackNamespaces = new Set(getFallbackNs());
@@ -78,11 +39,12 @@ export const EventEmitterSelective = (
         handler.fn({ value: undefined as any });
       }
     });
-  };
+  }
 
   let queue: (string[] | undefined)[] = [];
+
   // merge events in queue into one event
-  const solveQueue = () => {
+  function solveQueue() {
     if (queue.length === 0) {
       return;
     }
@@ -109,21 +71,60 @@ export const EventEmitterSelective = (
       : undefined;
 
     callHandlers(namespacesArray);
-  };
-
-  const emit = (ns?: string[], delayed?: boolean) => {
-    if (isActive()) {
-      queue.push(ns);
-      if (!delayed) {
-        solveQueue();
-      } else {
-        setTimeout(solveQueue, 0);
+  }
+
+  return Object.freeze({
+    emit(ns?: string[], delayed?: boolean) {
+      if (isActive()) {
+        queue.push(ns);
+        if (!delayed) {
+          solveQueue();
+        } else {
+          setTimeout(solveQueue, 0);
+        }
       }
-    }
-  };
-
-  return Object.freeze({ listenSome, listen, emit });
-};
+    },
+
+    listen(handler: Listener<undefined>) {
+      listeners.add(handler);
+      const result = {
+        unsubscribe: () => {
+          listeners.delete(handler);
+        },
+      };
+      return result;
+    },
+
+    listenSome(handler: Listener<undefined>) {
+      const handlerWrapper = {
+        fn: (e: ListenerEvent<undefined>) => {
+          handler(e);
+        },
+        namespaces: new Set<NsListType>(),
+      };
+
+      partialListeners.add(handlerWrapper);
+
+      const result = {
+        unsubscribe: () => {
+          partialListeners.delete(handlerWrapper);
+        },
+        subscribeNs: (ns: NsFallback) => {
+          getFallbackArray(ns).forEach((val) =>
+            handlerWrapper.namespaces.add(val)
+          );
+          if (ns === undefined) {
+            // subscribing to default ns
+            handlerWrapper.namespaces.add(getDefaultNs());
+          }
+          return result;
+        },
+      };
+
+      return result;
+    },
+  });
+}
 
 export type EventEmitterSelectiveInstance = {
   readonly listenSome: (handler: Listener<undefined>) => SubscriptionSelective;

package/src/Controller/Events/Events.ts

@@ -2,68 +2,57 @@ import { EventEmitter } from './EventEmitter';
 import { EventEmitterSelective } from './EventEmitterSelective';
 import { CacheDescriptorWithKey, TolgeeOn } from '../../types';
 
-export const Events = (
+export function Events(
   getFallbackNs: () => string[],
   getDefaultNs: () => string
-) => {
+) {
   let emitterActive = true;
 
   function isActive() {
     return emitterActive;
   }
 
-  const onPendingLanguageChange = EventEmitter<string>(isActive);
-  const onLanguageChange = EventEmitter<string>(isActive);
-  const onLoadingChange = EventEmitter<boolean>(isActive);
-  const onFetchingChange = EventEmitter<boolean>(isActive);
-  const onInitialLoaded = EventEmitter<void>(isActive);
-  const onRunningChange = EventEmitter<boolean>(isActive);
-  const onCacheChange = EventEmitter<CacheDescriptorWithKey>(isActive);
-  const onUpdate = EventEmitterSelective(isActive, getFallbackNs, getDefaultNs);
-
-  onInitialLoaded.listen(() => onUpdate.emit());
-  onLanguageChange.listen(() => onUpdate.emit());
-  onCacheChange.listen(({ value }) => {
-    onUpdate.emit([value.namespace], true);
+  const self = Object.freeze({
+    onPendingLanguageChange: EventEmitter<string>(isActive),
+    onLanguageChange: EventEmitter<string>(isActive),
+    onLoadingChange: EventEmitter<boolean>(isActive),
+    onFetchingChange: EventEmitter<boolean>(isActive),
+    onInitialLoaded: EventEmitter<void>(isActive),
+    onRunningChange: EventEmitter<boolean>(isActive),
+    onCacheChange: EventEmitter<CacheDescriptorWithKey>(isActive),
+    onUpdate: EventEmitterSelective(isActive, getFallbackNs, getDefaultNs),
+    setEmitterActive(active: boolean) {
+      emitterActive = active;
+    },
+    on: ((event, handler): any => {
+      switch (event) {
+        case 'pendingLanguage':
+          return self.onPendingLanguageChange.listen(handler as any);
+        case 'language':
+          return self.onLanguageChange.listen(handler as any);
+        case 'loading':
+          return self.onLoadingChange.listen(handler as any);
+        case 'fetching':
+          return self.onFetchingChange.listen(handler as any);
+        case 'initialLoad':
+          return self.onInitialLoaded.listen(handler as any);
+        case 'running':
+          return self.onRunningChange.listen(handler as any);
+        case 'cache':
+          return self.onCacheChange.listen(handler as any);
+        case 'update':
+          return self.onUpdate.listen(handler as any);
+      }
+    }) as TolgeeOn,
   });
 
-  const on: TolgeeOn = (event, handler): any => {
-    switch (event) {
-      case 'pendingLanguage':
-        return onPendingLanguageChange.listen(handler as any);
-      case 'language':
-        return onLanguageChange.listen(handler as any);
-      case 'loading':
-        return onLoadingChange.listen(handler as any);
-      case 'fetching':
-        return onFetchingChange.listen(handler as any);
-      case 'initialLoad':
-        return onInitialLoaded.listen(handler as any);
-      case 'running':
-        return onRunningChange.listen(handler as any);
-      case 'cache':
-        return onCacheChange.listen(handler as any);
-      case 'update':
-        return onUpdate.listen(handler as any);
-    }
-  };
-
-  function setEmitterActive(active: boolean) {
-    emitterActive = active;
-  }
+  self.onInitialLoaded.listen(() => self.onUpdate.emit());
+  self.onLanguageChange.listen(() => self.onUpdate.emit());
+  self.onCacheChange.listen(({ value }) =>
+    self.onUpdate.emit([value.namespace], true)
+  );
 
-  return Object.freeze({
-    onPendingLanguageChange,
-    onLanguageChange,
-    onLoadingChange,
-    onFetchingChange,
-    onInitialLoaded,
-    onRunningChange,
-    onCacheChange,
-    onUpdate,
-    setEmitterActive,
-    on,
-  });
-};
+  return self;
+}
 
 export type EventsInstance = ReturnType<typeof Events>;