@tolgee/core 4.9.2 → 4.9.3-rc.128edeb.0

package/src/__test/languageStorage.test.ts

@@ -0,0 +1,145 @@
+import { Tolgee, TolgeePlugin, TolgeeInstance } from '../index';
+
+describe('language storage plugin', () => {
+  let tolgee: TolgeeInstance;
+  let storedValue: string | undefined;
+  const StoragePlugin =
+    (value: any): TolgeePlugin =>
+    (tolgee, tools) => {
+      tools.setLanguageStorage({
+        getLanguage() {
+          return value;
+        },
+        setLanguage(language: string) {
+          storedValue = language;
+        },
+      });
+      return tolgee;
+    };
+
+  afterEach(() => {
+    tolgee.stop();
+  });
+
+  it('will restore language without loading', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin('en'))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const onFetchingHandler = jest.fn(() => {});
+    const onLoadingHandler = jest.fn(() => {});
+
+    tolgee.on('fetching', onFetchingHandler);
+    tolgee.on('loading', onLoadingHandler);
+
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('en');
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+
+    expect(onFetchingHandler).not.toBeCalled();
+    expect(onLoadingHandler).not.toBeCalled();
+  });
+
+  it('will restore language async', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const onFetchingHandler = jest.fn(() => {});
+    const onLoadingHandler = jest.fn(() => {});
+
+    tolgee.on('fetching', onFetchingHandler);
+    tolgee.on('loading', onLoadingHandler);
+
+    const runPromise = tolgee.run();
+    expect(tolgee.isLoading()).toBeTruthy();
+    expect(tolgee.isFetching()).toBeTruthy();
+
+    await runPromise;
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+    expect(onFetchingHandler).toBeCalledTimes(2);
+    expect(onLoadingHandler).toBeCalledTimes(2);
+  });
+
+  it('will fallback correctly', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve(undefined)))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const runPromise = tolgee.run();
+    expect(tolgee.getLanguage()).toEqual(undefined);
+
+    await runPromise;
+    expect(tolgee.getLanguage()).toEqual('es');
+  });
+
+  it('will return key before language is loaded', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+
+    const runPromise = tolgee.run();
+    expect(tolgee.t({ key: 'test' })).toEqual('test');
+
+    await runPromise;
+    expect(tolgee.t({ key: 'test' })).toEqual('Test');
+  });
+
+  it('will store language value on language change', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+          es: { test: 'Testa' },
+        },
+      });
+
+    tolgee.run();
+
+    await tolgee.changeLanguage('es');
+    expect(storedValue).toEqual('es');
+  });
+
+  it('will ignore invalid values', () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin('eq'))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+          es: { test: 'Testa' },
+        },
+      });
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('es');
+  });
+
+  it('will return invalid value if no available languages', () => {
+    tolgee = Tolgee().use(StoragePlugin('eq')).init({
+      defaultLanguage: 'es',
+    });
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('eq');
+  });
+});

package/src/__test/languages.test.ts

@@ -0,0 +1,112 @@
+import { Tolgee, TreeTranslationsData } from '../index';
+import { resolvablePromise } from './testTools';
+
+describe('language changes', () => {
+  it('changes language', async () => {
+    const tolgee = Tolgee({ language: 'en' });
+    expect(tolgee.getLanguage()).toEqual('en');
+    await tolgee.changeLanguage('es');
+    expect(tolgee.getLanguage()).toEqual('es');
+  });
+
+  it('returns correct translation', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'World' }, es: { hello: 'Mundo' } },
+    });
+    expect(tolgee.t({ key: 'hello' })).toEqual('World');
+    await tolgee.changeLanguage('es');
+    expect(tolgee.t({ key: 'hello' })).toEqual('Mundo');
+    await tolgee.changeLanguage('cs');
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello');
+  });
+
+  it('fetches language data correctly', async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: () => promiseEn,
+        es: () => promiseEs,
+      },
+    });
+    const runPromise = tolgee.run();
+    expect(tolgee.t({ key: 'test' })).toEqual('test');
+    expect(tolgee.getPendingLanguage()).toEqual('en');
+    resolveEn({ test: 'Test' });
+    await runPromise;
+    expect(tolgee.t({ key: 'test' })).toEqual('Test');
+
+    const langChangeEsPromise = tolgee.changeLanguage('es');
+    expect(tolgee.getPendingLanguage()).toEqual('es');
+    resolveEs({ test: 'Testa' });
+    await langChangeEsPromise;
+    expect(tolgee.t({ key: 'test' })).toEqual('Testa');
+  });
+
+  it('fetches fallback', async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEnGb, resolveEnGb] =
+      resolvablePromise<TreeTranslationsData>();
+    const [promiseEnIn, resolveEnIn] =
+      resolvablePromise<TreeTranslationsData>();
+
+    const tolgee = Tolgee({
+      language: 'es',
+      staticData: {
+        en: () => promiseEn,
+        es: () => promiseEs,
+        'en-GB': () => promiseEnGb,
+        'en-IN': () => promiseEnIn,
+      },
+      fallbackLanguage: {
+        es: 'en',
+        'en-GB': 'en',
+        'en-IN': ['en-GB', 'en'],
+      },
+    });
+
+    resolveEn({ color: 'Color', egg: 'Egg' });
+    resolveEs({ color: 'Pintar' });
+    await tolgee.run();
+
+    expect(tolgee.t({ key: 'color' })).toEqual('Pintar');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+
+    resolveEnGb({ color: 'Colour', india: 'India' });
+    resolveEnIn({ india: 'Blabla' });
+
+    await tolgee.changeLanguage('en-IN');
+    expect(tolgee.t({ key: 'color' })).toEqual('Colour');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+    expect(tolgee.t({ key: 'india' })).toEqual('Blabla');
+
+    await tolgee.changeLanguage('en-GB');
+    expect(tolgee.t({ key: 'color' })).toEqual('Colour');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+    expect(tolgee.t({ key: 'india' })).toEqual('India');
+
+    await tolgee.changeLanguage('en');
+    expect(tolgee.t({ key: 'color' })).toEqual('Color');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+    expect(tolgee.t({ key: 'india' })).toEqual('india');
+  });
+
+  it('will fallback to default value', () => {
+    const tolgee = Tolgee({
+      defaultLanguage: 'en',
+    });
+
+    expect(tolgee.getLanguage()).toEqual(undefined);
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('en');
+  });
+
+  it('will throw error when no language specified', () => {
+    const tolgee = Tolgee({});
+
+    expect(() => tolgee.run()).toThrow(/'language'/);
+  });
+});

package/src/__test/loading.test.ts

@@ -0,0 +1,39 @@
+import { Tolgee, TreeTranslationsData } from '../index';
+import { resolvablePromise } from './testTools';
+
+describe('loading', () => {
+  it('isLoading & isFetching', async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
+    const onLoadHandler = jest.fn(() => {});
+    const onFetchingHandler = jest.fn(() => {});
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: () => promiseEn,
+        es: () => promiseEs,
+      },
+    });
+    tolgee.on('initialLoad', onLoadHandler);
+    tolgee.on('fetching', onFetchingHandler);
+
+    const runPromise = tolgee.run();
+    expect(tolgee.isLoading()).toBeTruthy();
+    expect(tolgee.isFetching()).toBeTruthy();
+    resolveEn({});
+    await runPromise;
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+    expect(onLoadHandler).toBeCalledTimes(1);
+    expect(onFetchingHandler).toBeCalledTimes(2);
+
+    const changeLanguagePromise = tolgee.changeLanguage('es');
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeTruthy();
+    resolveEs({});
+    await changeLanguagePromise;
+    expect(onLoadHandler).toBeCalledTimes(1);
+    expect(onFetchingHandler).toBeCalledTimes(4);
+    expect(tolgee.isFetching()).toBeFalsy();
+  });
+});

package/src/__test/namespaces.test.ts

@@ -0,0 +1,99 @@
+import { Tolgee } from '../index';
+
+const tolgeeWithNamespaces = () => {
+  const promiseEnTest = jest.fn(() => Promise.resolve({ test: 'Test' }));
+  const promiseEnCommon = jest.fn(() => Promise.resolve({ cancel: 'Cancel' }));
+  const promiseEsTest = jest.fn(() => Promise.resolve({ test: 'Testa' }));
+  const promiseEsCommon = jest.fn(() =>
+    Promise.resolve({ cancel: 'Cancellar' })
+  );
+
+  return Tolgee({
+    language: 'en',
+    ns: ['common'],
+    staticData: {
+      'en:common': promiseEnCommon,
+      'en:test': promiseEnTest,
+      'es:common': promiseEsCommon,
+      'es:test': promiseEsTest,
+    },
+  });
+};
+
+describe('language changes', () => {
+  it('returns correct translation from namespace', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { hello: 'World' },
+        'en:common': { test: 'Test' },
+      },
+    });
+    expect(tolgee.t({ key: 'hello' })).toEqual('World');
+    expect(tolgee.t({ key: 'test' })).toEqual('test');
+    expect(tolgee.t({ key: 'test', ns: 'common' })).toEqual('Test');
+  });
+
+  it('uses defaultNs', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      defaultNs: 'common',
+      staticData: {
+        'en:common': { test: 'Test' },
+        'es:common': { test: 'Testa' },
+      },
+    });
+    await tolgee.run();
+
+    expect(tolgee.t({ key: 'test' })).toEqual('Test');
+    await tolgee.changeLanguage('es');
+    expect(tolgee.t({ key: 'test' })).toEqual('Testa');
+  });
+
+  it('active namespaces', async () => {
+    const tolgee = tolgeeWithNamespaces();
+    await tolgee.run();
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+
+    await tolgee.changeLanguage('es');
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancellar');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+
+    await tolgee.changeLanguage('en');
+    await tolgee.addActiveNs('test');
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('Test');
+
+    await tolgee.changeLanguage('es');
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancellar');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('Testa');
+  });
+
+  it('removing active namespaces', async () => {
+    const tolgee = tolgeeWithNamespaces();
+    await tolgee.run();
+    const handler = jest.fn();
+    tolgee.on('cache', handler);
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+
+    await tolgee.addActiveNs('test');
+    expect(handler).toBeCalledTimes(1);
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('Test');
+
+    tolgee.removeActiveNs('test');
+    await tolgee.changeLanguage('es');
+    expect(handler).toBeCalledTimes(2);
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancellar');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+  });
+});

package/src/__test/namespacesFallback.test.ts

@@ -0,0 +1,74 @@
+import { Tolgee } from '../Tolgee';
+
+describe('namespaces fallback', () => {
+  test('works with multiple and default', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:first': { '1': 'first' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['first', 'second'],
+    });
+
+    expect(tolgee.t({ key: '0' })).toEqual('noNamespace');
+    expect(tolgee.t({ key: '1' })).toEqual('first');
+    expect(tolgee.t({ key: '2' })).toEqual('second');
+    expect(tolgee.t({ key: '4' })).toEqual('4');
+    expect(tolgee.t({ key: '4', orEmpty: true })).toEqual('');
+  });
+
+  test('works when no fallback specified', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['first', 'second'],
+    });
+
+    expect(tolgee.t({ key: '0' })).toEqual('noNamespace');
+    expect(tolgee.t({ key: '1' })).toEqual('1');
+    expect(tolgee.t({ key: '2' })).toEqual('second');
+    expect(tolgee.t({ key: '4' })).toEqual('4');
+    expect(tolgee.t({ key: '4', orEmpty: true })).toEqual('');
+  });
+
+  test('works when data present but no fallback', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:first': { '1': 'first' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['second'],
+    });
+
+    expect(tolgee.t({ key: '0' })).toEqual('noNamespace');
+    expect(tolgee.t({ key: '1' })).toEqual('1');
+    expect(tolgee.t({ key: '2' })).toEqual('second');
+    expect(tolgee.t({ key: '4' })).toEqual('4');
+    expect(tolgee.t({ key: '4', orEmpty: true })).toEqual('');
+  });
+
+  test('works with override', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:first': { '1': 'first' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['second'],
+    });
+
+    expect(tolgee.t({ key: '1' })).toEqual('1');
+    expect(tolgee.t({ key: '1', ns: 'first' })).toEqual('first');
+    expect(tolgee.t({ key: '0', ns: 'first' })).toEqual('0');
+    expect(tolgee.t({ key: '2', ns: 'first' })).toEqual('2');
+    expect(tolgee.t({ key: '2', ns: 'second' })).toEqual('second');
+  });
+});

package/src/__test/plugins.test.ts

@@ -0,0 +1,136 @@
+import { Tolgee } from '../Tolgee';
+import {
+  FinalFormatterInterface,
+  FormatterInterface,
+  FormatterInterfaceFormatParams,
+  ObserverInterface,
+  TolgeePlugin,
+  WrapperWrapFunction,
+  ObserverOptions,
+} from '../types';
+
+const testObserver =
+  (
+    outputNotFormattable: boolean,
+    onCreate?: (options: ObserverOptions) => void
+  ): ObserverInterface =>
+  ({ options }) => {
+    const wrap: WrapperWrapFunction = ({ key, translation }) => {
+      return `${key}|${translation}`;
+    };
+    const unwrap = (input: string) => {
+      const [key, text] = input.split('|');
+      return { text, keys: [{ key }] };
+    };
+
+    const stop = () => {};
+    const run = () => {};
+
+    const retranslate = () => {};
+
+    onCreate?.(options);
+
+    return Object.freeze({
+      wrap,
+      unwrap,
+      run,
+      stop,
+      retranslate,
+      highlight: () => ({ unhighlight: () => {} }),
+      outputNotFormattable,
+    });
+  };
+
+const testFormatter1: FormatterInterface = {
+  format: ({ translation }: FormatterInterfaceFormatParams) => {
+    return `(1${translation})`;
+  },
+};
+
+const testFormatter2: FormatterInterface = {
+  format: ({ translation }: FormatterInterfaceFormatParams) => {
+    return `(2${translation})`;
+  },
+};
+
+const testFinalFormatter: FinalFormatterInterface = {
+  format: ({ translation }: FormatterInterfaceFormatParams) => {
+    return { final: translation };
+  },
+};
+
+const observerPlugin =
+  (
+    outputNotFormattable: boolean,
+    onCreate?: (options: ObserverOptions) => void
+  ): TolgeePlugin =>
+  (tolgee, tools) => {
+    tools.setObserver(testObserver(outputNotFormattable, onCreate));
+    return tolgee;
+  };
+
+const formattersPlugin: TolgeePlugin = (tolgee, tools) => {
+  tools.addFormatter(testFormatter1);
+  tools.addFormatter(testFormatter2);
+  tools.setFinalFormatter(testFinalFormatter);
+  return tolgee;
+};
+
+describe('plugins', () => {
+  it('wraps and formats translation', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    tolgee.use(observerPlugin(false));
+    tolgee.run();
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+
+    tolgee.use(formattersPlugin);
+    expect(tolgee.t({ key: 'hello' })).toEqual({ final: '(2(1hello|world))' });
+    tolgee.stop();
+  });
+
+  it("won't format when observer doesn't return formattable text", () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    tolgee.use(observerPlugin(true));
+    tolgee.run();
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+
+    tolgee.use(formattersPlugin);
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+    tolgee.stop();
+  });
+
+  it("won't wrap before run", () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    tolgee.use(observerPlugin(false));
+    expect(tolgee.t({ key: 'hello' })).toEqual('world');
+    tolgee.run();
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+  });
+
+  it('observer recieves options', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    const restrictedElements = ['test'];
+    tolgee.setObserverOptions({
+      restrictedElements,
+    });
+    const onCreate = jest.fn();
+    tolgee.use(observerPlugin(false, onCreate));
+    tolgee.run();
+    expect(onCreate).toBeCalledTimes(1);
+    expect(onCreate.mock.calls[0][0].restrictedElements).toEqual(
+      restrictedElements
+    );
+  });
+});

package/src/__test/testTools.ts

@@ -0,0 +1,7 @@
+export const resolvablePromise = <T = any>() => {
+  let resolve: (value: T) => void;
+  const promise = new Promise<T>((innerResolve) => {
+    resolve = innerResolve;
+  });
+  return [promise, resolve!] as const;
+};

package/src/{Constants/Global.ts → constants.ts}

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

package/src/helpers.ts

@@ -0,0 +1,17 @@
+export function isPromise(value: any) {
+  return Boolean(value && typeof value.then === 'function');
+}
+
+export const 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`;

package/src/index.ts

@@ -1,10 +1,11 @@
 export { Tolgee } from './Tolgee';
-export { TolgeeConfig } from './TolgeeConfig';
-export { ModifierKey } from './Constants/ModifierKey';
-export { TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE } from './Constants/Global';
-export * from './modules';
-export * from './types/DTOs';
+export {
+  RESTRICTED_ASCENDANT_ATTRIBUTE,
+  TOLGEE_ATTRIBUTE_NAME,
+  TOLGEE_HIGHLIGHTER_CLASS,
+  TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE,
+} from './constants';
 export * from './types';
-export * from './Constants/Global';
-export * from './helpers/NodeHelper';
-export * from './helpers/TextHelper';
+export { getTranslateParams } from './TranslateParams';
+export { getFallback, getFallbackArray } from './Controller/State/helpers';
+export { FormatSimple } from './FormatSimple/FormatSimple';