@tolgee/core 4.9.2 → 5.0.0-rc.0b3e627.0

package/src/Events/EventEmitterSelective.test.ts

@@ -0,0 +1,108 @@
+import { EventEmitterSelective } from './EventEmitterSelective';
+
+describe('event emitter selective', () => {
+  it('subscribes to key', () => {
+    const emitter = EventEmitterSelective<void>();
+    const handler = jest.fn();
+    const listener = emitter.listenSome(handler);
+    listener.subscribeKey({ key: 'test' });
+    listener.subscribeKey({ key: 'abcd' });
+
+    emitter.emit({ key: 'test' });
+    emitter.emit({ key: 'youda' });
+    expect(handler).toBeCalledTimes(1);
+    listener.unsubscribe();
+    emitter.emit();
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  it('subscribes to key with namespaces', () => {
+    const emitter = EventEmitterSelective<void>();
+    const handler = jest.fn();
+    const listener = emitter.listenSome(handler);
+
+    listener.subscribeKey({ key: 'test', ns: 'common' });
+    listener.subscribeKey({ key: 'abcd', ns: ['test', 'abcd'] });
+
+    emitter.emit({ key: 'youda', ns: ['common'] });
+    emitter.emit({ key: 'test', ns: ['youda'] });
+    expect(handler).toBeCalledTimes(0);
+    emitter.emit({ key: 'abcd', ns: ['abcd'] });
+    emitter.emit({ ns: ['test'] });
+    expect(handler).toBeCalledTimes(2);
+    listener.unsubscribe();
+    emitter.emit();
+    expect(handler).toBeCalledTimes(2);
+  });
+
+  it('unsubscribes', () => {
+    const emitter = EventEmitterSelective<void>();
+    const handler = jest.fn();
+    const listener = emitter.listenSome(handler);
+
+    listener.subscribeKey({ key: 'test', ns: 'common' });
+    listener.subscribeKey({ key: 'abcd', ns: ['test', 'abcd'] });
+
+    emitter.emit({ key: 'youda', ns: ['common'] });
+    emitter.emit({ key: 'test', ns: ['youda'] });
+    expect(handler).toBeCalledTimes(0);
+    emitter.emit({ key: 'abcd', ns: ['abcd'] });
+    emitter.emit({ ns: ['test'] });
+    expect(handler).toBeCalledTimes(2);
+
+    listener.unsubscribeKey({ key: 'abcd', ns: ['test', 'abcd'] });
+    emitter.emit({ key: 'abcd' });
+    emitter.emit({ ns: ['test'] });
+
+    listener.unsubscribe();
+    emitter.emit();
+    expect(handler).toBeCalledTimes(2);
+  });
+
+  it('groups events correctly', async () => {
+    const emitter = EventEmitterSelective<void>();
+    const handler = jest.fn();
+    const hanlderAll = jest.fn();
+    const listener = emitter.listenSome(handler);
+    const listenerAll = emitter.listen(hanlderAll);
+
+    listener.subscribeKey({ key: 'abcd', ns: ['test', 'abcd'] });
+
+    emitter.emit({ key: 'abcd' }, true);
+    emitter.emit({ ns: ['opqrst'] }, true);
+
+    await Promise.resolve();
+
+    expect(hanlderAll).toBeCalledTimes(1);
+    expect(handler).toBeCalledTimes(1);
+
+    emitter.emit({ key: 'youda', ns: ['test'] }, true);
+    emitter.emit({ key: 'filda', ns: ['test'] });
+
+    expect(hanlderAll).toBeCalledTimes(2);
+    expect(handler).toBeCalledTimes(1);
+
+    listener.unsubscribe();
+    listenerAll.unsubscribe();
+    emitter.emit();
+  });
+
+  it('subscribes to ns only', async () => {
+    const emitter = EventEmitterSelective<void>();
+    const handler = jest.fn();
+    const listener = emitter.listenSome(handler);
+    listener.subscribeNs(['test']);
+
+    emitter.emit({ key: 'youda' });
+    expect(handler).toBeCalledTimes(1);
+
+    emitter.emit({ ns: ['test'] });
+    expect(handler).toBeCalledTimes(2);
+
+    emitter.emit({ ns: ['youda'] });
+    expect(handler).toBeCalledTimes(2);
+
+    emitter.emit({ key: 'youda', ns: ['youda'] });
+    expect(handler).toBeCalledTimes(2);
+  });
+});

package/src/Events/EventEmitterSelective.ts

@@ -0,0 +1,160 @@
+import { getFallbackArray } from '../Controller/State/helpers';
+import {
+  FallbackNSTranslation,
+  KeyDescriptor,
+  KeyDescriptorInternal,
+  ListenerHandler,
+  ListenerHandlerEvent,
+} from '../types';
+
+type HandlerWrapperType = {
+  fn: ListenerHandler<undefined>;
+  keys: Map<string, number>;
+  namespaces: Map<string | undefined, number>;
+};
+
+function incrementInMap(map: Map<any, number>, value: any) {
+  const currNum = map.get(value) || 0;
+  map.set(value, currNum + 1);
+}
+
+function decrementInMap(map: Map<any, number>, value: any) {
+  let currNum = map.get(value) || 1;
+  currNum -= 1;
+  if (currNum <= 0) {
+    map.delete(value);
+  } else {
+    map.set(value, currNum);
+  }
+}
+
+export const EventEmitterSelective = <T>() => {
+  const listeners: Set<ListenerHandler<T>> = new Set();
+  const partialListeners: Set<HandlerWrapperType> = new Set();
+
+  const listen = (handler: ListenerHandler<T>) => {
+    listeners.add(handler);
+    const result = {
+      unsubscribe: () => {
+        listeners.delete(handler);
+      },
+    };
+    return result;
+  };
+
+  const listenSome = (handler: ListenerHandler<undefined>) => {
+    const handlerWrapper = {
+      fn: (e: ListenerHandlerEvent<undefined>) => {
+        handler(e);
+      },
+      keys: new Map<string, number>(),
+      namespaces: new Map<string | undefined, number>(),
+    };
+
+    partialListeners.add(handlerWrapper);
+
+    const result = {
+      unsubscribe: () => {
+        partialListeners.delete(handlerWrapper);
+      },
+      subscribeNs: (ns: FallbackNSTranslation) => {
+        getFallbackArray(ns).forEach((val) =>
+          incrementInMap(handlerWrapper.namespaces, val)
+        );
+        return result;
+      },
+      unsubscribeNs: (ns: FallbackNSTranslation) => {
+        getFallbackArray(ns).forEach((val) =>
+          decrementInMap(handlerWrapper.namespaces, val)
+        );
+        return result;
+      },
+      subscribeKey: (descriptor: KeyDescriptor) => {
+        const { key, ns } = descriptor;
+        incrementInMap(handlerWrapper.keys, key);
+        getFallbackArray(ns).forEach((val) =>
+          incrementInMap(handlerWrapper.namespaces, val)
+        );
+        if (ns === undefined) {
+          // subscribing to all namespaces
+          incrementInMap(handlerWrapper.namespaces, undefined);
+        }
+        return result;
+      },
+      unsubscribeKey: (descriptor: KeyDescriptor) => {
+        const { key, ns } = descriptor;
+        decrementInMap(handlerWrapper.keys, key);
+        getFallbackArray(ns).forEach((val) =>
+          decrementInMap(handlerWrapper.namespaces, val)
+        );
+        if (ns === undefined) {
+          // subscribing to all namespaces
+          decrementInMap(handlerWrapper.namespaces, undefined);
+        }
+        return result;
+      },
+    };
+
+    return result;
+  };
+
+  const callHandlers = (key: string | undefined, ns: string[] | undefined) => {
+    partialListeners.forEach((handler) => {
+      const nsMentioned = ns !== undefined;
+      const nsMatches =
+        handler.namespaces.has(undefined) ||
+        ns?.findIndex((ns) => handler.namespaces.has(ns)) !== -1;
+      const keyMentioned = key !== undefined;
+      const keyMatches =
+        key === undefined || handler.keys.has(key) || handler.keys.size === 0;
+      if ((!nsMentioned || nsMatches) && (!keyMentioned || keyMatches)) {
+        handler.fn({ value: undefined as any });
+      }
+    });
+  };
+
+  let queue: (KeyDescriptorInternal | undefined)[] = [];
+  const solveQueue = () => {
+    if (queue.length === 0) {
+      return;
+    }
+    listeners.forEach((handler) => {
+      handler({ value: undefined as any });
+    });
+
+    let namespaces = [] as string[] | undefined;
+    let keys = [] as string[] | undefined;
+    queue.forEach((descriptor) => {
+      if (descriptor?.ns === undefined) {
+        namespaces = undefined;
+      } else if (namespaces !== undefined) {
+        namespaces = [...namespaces, ...descriptor.ns];
+      }
+      if (descriptor?.key === undefined) {
+        keys = undefined;
+      } else if (keys !== undefined) {
+        keys = [...keys, descriptor.key];
+      }
+    });
+    (keys || [undefined]).forEach((key) => {
+      callHandlers(key, namespaces);
+    });
+    queue = [];
+  };
+  const emit = (descriptor?: KeyDescriptorInternal, delayed?: boolean) => {
+    queue.push(descriptor);
+    if (!delayed) {
+      solveQueue();
+    } else {
+      Promise.resolve().then(() => {
+        solveQueue();
+      });
+    }
+  };
+
+  return Object.freeze({ listenSome, listen, emit });
+};
+
+export type EventEmitterSelectiveType<T> = ReturnType<
+  typeof EventEmitterSelective<T>
+>;

package/src/Events/Events.ts

@@ -0,0 +1,66 @@
+import { EventEmitter } from './EventEmitter';
+import { EventEmitterSelective } from './EventEmitterSelective';
+import {
+  CacheDescriptorWithKey,
+  KeyDescriptorInternal,
+  ListenerHandler,
+  TolgeeOn,
+} from '../types';
+
+export const Events = () => {
+  const onPendingLanguageChange = EventEmitter<string>();
+  const onLanguageChange = EventEmitter<string>();
+  const onKeyChange = EventEmitter<KeyDescriptorInternal>();
+  const onLoadingChange = EventEmitter<boolean>();
+  const onFetchingChange = EventEmitter<boolean>();
+  const onInitialLoaded = EventEmitter<void>();
+  const onKeyUpdate = EventEmitterSelective<void>();
+  const onCacheChange = EventEmitter<CacheDescriptorWithKey>();
+  const onRunningChange = EventEmitter<boolean>();
+
+  onInitialLoaded.listen(() => onKeyUpdate.emit());
+  onLanguageChange.listen(() => onKeyUpdate.emit());
+  onCacheChange.listen(({ value }) => {
+    onKeyUpdate.emit({ ns: [value.namespace], key: value.key }, true);
+  });
+
+  const on: TolgeeOn = (event, handler): any => {
+    switch (event) {
+      case 'pendingLanguage':
+        return onPendingLanguageChange.listen(
+          handler as ListenerHandler<string>
+        );
+      case 'language':
+        return onLanguageChange.listen(handler as ListenerHandler<string>);
+      case 'loading':
+        return onLoadingChange.listen(handler as ListenerHandler<boolean>);
+      case 'fetching':
+        return onFetchingChange.listen(handler as ListenerHandler<boolean>);
+      case 'initialLoad':
+        return onInitialLoaded.listen(handler as ListenerHandler<void>);
+      case 'running':
+        return onRunningChange.listen(handler as ListenerHandler<boolean>);
+      case 'cache':
+        return onCacheChange.listen(
+          handler as ListenerHandler<CacheDescriptorWithKey>
+        );
+      case 'keyUpdate':
+        return onKeyUpdate.listen(handler as ListenerHandler<void>);
+    }
+  };
+
+  return Object.freeze({
+    onPendingLanguageChange,
+    onLanguageChange,
+    onKeyChange,
+    onKeyUpdate,
+    onLoadingChange,
+    onFetchingChange,
+    onInitialLoaded,
+    onRunningChange,
+    onCacheChange,
+    on,
+  });
+};
+
+export type EventServiceType = ReturnType<typeof Events>;