@tolgee/core 5.0.0-rc.9be0f0e.0 → 5.0.0

package/src/Events/EventEmitterSelective.test.ts

@@ -1,108 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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>;

package/src/Tolgee.ts

@@ -1,77 +0,0 @@
-import { Events } from './Events/Events';
-import { Controller } from './Controller/Controller';
-import { Options, TolgeeInstance, TolgeePlugin } from './types';
-
-export const Tolgee = (options?: Partial<Options>): TolgeeInstance => {
-  const events = Events();
-  const controller = Controller({
-    events,
-    options,
-  });
-
-  const pluginTools = Object.freeze({
-    setFinalFormatter: controller.setFinalFormatter,
-    addFormatter: controller.addFormatter,
-    setObserver: controller.setObserver,
-    getObserver: controller.getObserver,
-    setUi: controller.setUi,
-    getUi: controller.getUi,
-    setDevBackend: controller.setDevBackend,
-    addBackend: controller.addBackend,
-    setLanguageDetector: controller.setLanguageDetector,
-    setLanguageStorage: controller.setLanguageStorage,
-  });
-
-  const withRestart = (callback: () => void) => {
-    const wasRunning = controller.isRunning();
-    wasRunning && controller.stop();
-    callback();
-    wasRunning && controller.run();
-  };
-
-  const tolgee: TolgeeInstance = Object.freeze({
-    // event listeners
-    on: events.on,
-    onKeyUpdate: events.onKeyUpdate.listenSome,
-
-    // state
-    getLanguage: controller.getLanguage,
-    getPendingLanguage: controller.getPendingLanguage,
-    changeLanguage: controller.changeLanguage,
-    changeTranslation: controller.changeTranslation,
-    addActiveNs: controller.addActiveNs,
-    removeActiveNs: controller.removeActiveNs,
-    loadRecords: controller.loadRecords,
-    loadRecord: controller.loadRecord,
-    addStaticData: controller.addStaticData,
-    getRecord: controller.getRecord,
-    getAllRecords: controller.getAllRecords,
-    isLoaded: controller.isLoaded,
-    isInitialLoading: controller.isInitialLoading,
-    isLoading: controller.isLoading,
-    isFetching: controller.isFetching,
-    isRunning: controller.isRunning,
-    run: controller.run,
-    stop: controller.stop,
-    t: controller.t,
-    highlight: controller.highlight,
-    getInitialOptions: controller.getInitialOptions,
-    isDev: controller.isDev,
-    wrap: controller.wrap,
-    unwrap: controller.unwrap,
-
-    // plugins
-    use: (plugin: TolgeePlugin | undefined) => {
-      if (plugin) {
-        withRestart(() => plugin(tolgee, pluginTools));
-      }
-      return tolgee;
-    },
-    init: (options: Partial<Options>) => {
-      withRestart(() => controller.init(options));
-      return tolgee;
-    },
-  });
-
-  return tolgee;
-};

package/src/constants.ts

@@ -1,7 +0,0 @@
-export const RESTRICTED_ASCENDANT_ATTRIBUTE = 'data-tolgee-restricted';
-export const TOLGEE_ATTRIBUTE_NAME = '_tolgee';
-export const TOLGEE_HIGHLIGHTER_CLASS = '_tolgee-highlighter';
-export const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = 'data-tolgee-key-only';
-
-// needs to be same as in @tolgee/ui package
-export const DEVTOOLS_ID = '__tolgee_dev_tools';