@tolgee/core 4.9.2 → 4.9.3-rc.04b22e6.0

package/src/TranslateParams.ts

@@ -0,0 +1,51 @@
+import {
+  CombinedOptions,
+  TFnType,
+  TranslateOptions,
+  TranslateProps,
+} from './types';
+
+function parseCombinedOptions({
+  ns,
+  noWrap,
+  orEmpty,
+  params,
+  ...rest
+}: CombinedOptions<any>): Partial<TranslateProps> {
+  const options: Required<TranslateOptions<any>> = {
+    ns: ns!,
+    noWrap: noWrap!,
+    orEmpty: orEmpty!,
+    params: {
+      ...rest,
+      ...params,
+    },
+  };
+  return options;
+}
+
+export const getTranslateParams: TFnType<any, TranslateProps<any>> = (
+  keyOrProps,
+  ...params
+) => {
+  let result = {} as TranslateProps<any>;
+  let options: CombinedOptions<any> | undefined;
+  if (typeof keyOrProps === 'object') {
+    result = keyOrProps;
+  } else {
+    result.key = keyOrProps;
+    if (typeof params[0] === 'string') {
+      result.defaultValue = params[0];
+      options = params[1] as CombinedOptions<any>;
+    } else if (typeof params[0] === 'object') {
+      options = params[0] as CombinedOptions<any>;
+    }
+  }
+  if (options) {
+    result = {
+      ...parseCombinedOptions(options),
+      ...result,
+    };
+  }
+  return result;
+};

package/src/__test/backend.test.ts

@@ -0,0 +1,48 @@
+import { Tolgee } from '../Tolgee';
+import { BackendInterface, TolgeePlugin } from '../types';
+
+const data = {
+  en: {
+    common: { cancel: 'Cancel' },
+    test: { test: 'Test' },
+  },
+  es: {
+    common: { cancel: 'Cancellar' },
+    test: { test: 'Testar' },
+  },
+} as any;
+
+const backendNormal: BackendInterface = {
+  getRecord({ language, namespace = '' }) {
+    return data[language]?.[namespace];
+  },
+};
+
+const backendDev: BackendInterface = {
+  getRecord() {
+    return Promise.resolve({ cancel: 'Dev' });
+  },
+};
+
+const backendPlugin: TolgeePlugin = (tolgee, tools) => {
+  tools.addBackend(backendNormal);
+  tools.setDevBackend(backendDev);
+  return tolgee;
+};
+
+describe('backend plugins', () => {
+  it('uses plugin to fetch', async () => {
+    const tolgee = Tolgee()
+      .use(backendPlugin)
+      .init({
+        ns: ['common', 'test'],
+        language: 'en',
+      });
+    await tolgee.run();
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    tolgee.stop();
+    tolgee.init({ apiUrl: 'asdfasdf', apiKey: 'test' });
+    await tolgee.run();
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Dev');
+  });
+});

package/src/__test/cache.test.ts

@@ -0,0 +1,148 @@
+import { Tolgee } from '../Tolgee';
+import { TolgeeInstance, TolgeePlugin, TreeTranslationsData } from '../types';
+import { resolvablePromise } from './testTools';
+
+const waitForInitialLoad = (tolgee: TolgeeInstance) =>
+  new Promise<void>((resolve) => {
+    const { unsubscribe } = tolgee.on('initialLoad', () => {
+      unsubscribe();
+      resolve();
+    });
+  });
+
+const DevToolsPlugin =
+  (postfix = ''): TolgeePlugin =>
+  (tolgee, tools) => {
+    tolgee.init({ apiKey: 'test', apiUrl: 'test' });
+    tools.setDevBackend({
+      getRecord({ language, namespace }) {
+        return Promise.resolve({
+          test: { sub: `${language}.${namespace || 'default'}${postfix}` },
+        });
+      },
+    });
+    return tolgee;
+  };
+
+describe('cache', () => {
+  let tolgee: TolgeeInstance;
+
+  beforeEach(async () => {
+    tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { test: { sub: 'subtestEn' } },
+        cs: { 'test.sub': 'subtestCs' },
+      },
+    });
+  });
+
+  afterEach(() => {
+    tolgee.stop();
+  });
+
+  it('stores initial data correctly', async () => {
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    await tolgee.changeLanguage('cs');
+    expect(tolgee.t('test.sub')).toEqual('subtestCs');
+  });
+
+  it('ignores empty values', async () => {
+    tolgee.addStaticData({
+      en: { sub: { test: 'Test', null: null, undefined: undefined } },
+    });
+    expect(tolgee.t('sub.test')).toEqual('Test');
+    expect(tolgee.t('sub.null')).toEqual('sub.null');
+    expect(tolgee.t('sub.undefined')).toEqual('sub.undefined');
+  });
+
+  it('returns correct data when in dev mode', async () => {
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    tolgee.use(DevToolsPlugin());
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    const changeLangPromise = tolgee.changeLanguage('cs');
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    await changeLangPromise;
+    expect(tolgee.t('test.sub')).toEqual('cs.default');
+  });
+
+  it('invalidates the cache when switching to dev', async () => {
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    tolgee.use(DevToolsPlugin());
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+
+    await new Promise<void>((resolve) => {
+      const { unsubscribe } = tolgee.on('initialLoad', async () => {
+        expect(tolgee.t('test.sub')).toEqual('en.default');
+        unsubscribe();
+        resolve();
+      });
+    });
+  });
+
+  it('works with switching to different dev backend', async () => {
+    tolgee.use(DevToolsPlugin());
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    tolgee.use(DevToolsPlugin('.new'));
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+
+    await waitForInitialLoad(tolgee);
+    expect(tolgee.t('test.sub')).toEqual('en.default.new');
+  });
+
+  it('updates initial data correctly', async () => {
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    tolgee.addStaticData({ en: { test: { sub: 'newSubtestEn' } } });
+    expect(tolgee.t('test.sub')).toEqual('newSubtestEn');
+  });
+
+  it('ignores new initial data when already in dev mode', async () => {
+    tolgee.use(DevToolsPlugin());
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    tolgee.addStaticData({ en: { test: { sub: 'newSubtestEn' } } });
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+  });
+
+  it('gets all records', async () => {
+    await tolgee.run();
+    expect(tolgee.getAllRecords().length).toEqual(2);
+  });
+
+  it('fetching works with namespaces', async () => {
+    tolgee.use(DevToolsPlugin());
+    const runPromise = tolgee.run();
+    expect(tolgee.isFetching()).toBeTruthy();
+    await runPromise;
+    expect(tolgee.t('test.sub', { ns: 'common' })).toEqual('test.sub');
+    const nsPromise = tolgee.addActiveNs('common');
+    expect(tolgee.isFetching()).toBeTruthy();
+    expect(tolgee.isFetching('common')).toBeTruthy();
+    expect(tolgee.isFetching('nonexistant')).toBeFalsy();
+    await nsPromise;
+    expect(tolgee.t('test.sub', { ns: 'common' })).toEqual('en.common');
+    expect(tolgee.isFetching()).toBeFalsy();
+  });
+
+  it("pending requests won't rewrite cache when reinitialized", async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: () => promiseEn,
+      },
+    });
+    tolgee.run();
+    await Promise.resolve();
+    tolgee.use(DevToolsPlugin());
+    await waitForInitialLoad(tolgee);
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    resolveEn({ test: { sub: 'Invalid' } });
+    await Promise.resolve();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+  });
+});

package/src/__test/client.test.ts

@@ -0,0 +1,48 @@
+import { Tolgee } from '../index';
+
+describe('using tolgee as client', () => {
+  it('fetch data without running', async () => {
+    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' })
+    );
+
+    const tolgee = Tolgee({
+      language: 'en',
+      ns: ['common'],
+      staticData: {
+        'en:common': promiseEnCommon,
+        'en:test': promiseEnTest,
+        'es:common': promiseEsCommon,
+        'es:test': promiseEsTest,
+      },
+    });
+
+    const enTest = await tolgee.loadRecord({
+      language: 'en',
+      namespace: 'test',
+    });
+    expect(promiseEnTest).toBeCalledTimes(1);
+    expect(promiseEnCommon).not.toBeCalled();
+    expect(enTest).toEqual(new Map([['test', 'Test']]));
+
+    const enCommon = await tolgee.loadRecord({
+      language: 'en',
+      namespace: 'common',
+    });
+    expect(promiseEnCommon).toBeCalledTimes(1);
+    expect(enCommon).toEqual(new Map([['cancel', 'Cancel']]));
+
+    const esTest = await tolgee.loadRecord({
+      language: 'es',
+      namespace: 'test',
+    });
+    expect(promiseEsTest).toBeCalledTimes(1);
+    expect(promiseEsCommon).not.toBeCalled();
+    expect(esTest).toEqual(new Map([['test', 'Testa']]));
+  });
+});

package/src/__test/events.test.ts

@@ -0,0 +1,33 @@
+import { Tolgee } from '../index';
+
+describe('events', () => {
+  it('emits language change event', async () => {
+    const tolgee = Tolgee({ language: 'en' });
+    const handler = jest.fn((lang) => {});
+    tolgee.on('language', handler);
+    await tolgee.changeLanguage('es');
+    expect(handler).toHaveBeenCalledWith({ value: 'es' });
+  });
+
+  it('correctly emits translation change listeners', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { hello: 'World', language: 'English' },
+        es: { hello: 'Mundo', language: 'Spanish' },
+      },
+    });
+    const helloHandler = jest.fn((data) => {});
+    const languageHandler = jest.fn((data) => {});
+
+    tolgee.onKeyUpdate(helloHandler).subscribeKey({ key: 'hello' });
+    tolgee.onKeyUpdate(languageHandler).subscribeKey({ key: 'language' });
+
+    tolgee.changeTranslation({ language: 'es' }, 'hello', 'Světe');
+    tolgee.changeLanguage('es');
+
+    await Promise.resolve();
+    expect(helloHandler).toHaveBeenCalledTimes(1);
+    expect(languageHandler).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__test/format.simple.test.ts

@@ -0,0 +1,26 @@
+import { FormatSimple } from '../FormatSimple/FormatSimple';
+import { Tolgee } from '../Tolgee';
+
+describe('format simple', () => {
+  it('works with parameters', () => {
+    const tolgee = Tolgee()
+      .use(FormatSimple())
+      .init({
+        language: 'en',
+        staticData: { en: { apples: 'Bob has { num } apples' } },
+      });
+    expect(tolgee.t('apples', { num: 7 })).toEqual('Bob has 7 apples');
+  });
+
+  it('throws an error when parameter missing', () => {
+    const tolgee = Tolgee()
+      .use(FormatSimple())
+      .init({
+        language: 'en',
+        staticData: { en: { apples: 'Bob has { num } apples' } },
+      });
+    expect(() => tolgee.t('apples')).toThrow(
+      'Missing parameter "num" in "Bob has { num } apples"'
+    );
+  });
+});

package/src/__test/initialization.test.ts

@@ -0,0 +1,85 @@
+import { Tolgee } from '../index';
+
+describe('initialization behavior', () => {
+  it("change in state before running won't trigger fetch", async () => {
+    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' })
+    );
+
+    const tolgee = Tolgee({
+      language: 'en',
+      ns: ['common'],
+      staticData: {
+        'en:common': promiseEnCommon,
+        'en:test': promiseEnTest,
+        'es:common': promiseEsCommon,
+        'es:test': promiseEsTest,
+      },
+    });
+    const onInitialLoad = jest.fn();
+    const onRunningChange = jest.fn();
+    tolgee.on('initialLoad', onInitialLoad);
+    tolgee.on('running', onRunningChange);
+
+    await tolgee.changeLanguage('es');
+    await tolgee.addActiveNs('test');
+    expect(promiseEsCommon).not.toBeCalled();
+    expect(promiseEnCommon).not.toBeCalled();
+    expect(promiseEsTest).not.toBeCalled();
+    expect(promiseEnTest).not.toBeCalled();
+    expect(tolgee.isLoaded()).toBeFalsy();
+
+    await tolgee.run();
+    expect(promiseEsCommon).toBeCalled();
+    expect(promiseEnCommon).not.toBeCalled();
+    expect(promiseEsTest).toBeCalled();
+    expect(promiseEnTest).not.toBeCalled();
+    expect(tolgee.isLoaded()).toBeTruthy();
+
+    tolgee.stop();
+
+    expect(onInitialLoad).toBeCalledTimes(1);
+    expect(onRunningChange).toBeCalledTimes(2);
+  });
+
+  it("won't start loading when nothing to load", async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      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()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+
+    await runPromise;
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+    expect(onFetchingHandler).not.toBeCalled();
+    expect(onLoadingHandler).not.toBeCalled();
+  });
+
+  it('emits keyUpdate on initialLoad', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    const onKeyChange = jest.fn();
+    tolgee.on('keyUpdate', onKeyChange);
+    expect(onKeyChange).toBeCalledTimes(0);
+    await tolgee.run();
+    expect(onKeyChange).toBeCalledTimes(1);
+  });
+});

package/src/__test/jest-setup.ts

@@ -0,0 +1,2 @@
+// In your own jest-setup.js (or any other name)
+import '@testing-library/jest-dom';

package/src/__test/languageDetection.test.ts

@@ -0,0 +1,129 @@
+import { Tolgee, TolgeePlugin, TolgeeInstance } from '../index';
+
+const DetectionPlugin =
+  (value: any): TolgeePlugin =>
+  (tolgee, tools) => {
+    tools.setLanguageDetector({
+      getLanguage() {
+        return value;
+      },
+    });
+    return tolgee;
+  };
+
+describe('language detection plugin', () => {
+  let tolgee: TolgeeInstance;
+
+  afterEach(() => {
+    tolgee.stop();
+  });
+
+  it('will detect language without loading', async () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin('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 detect language async', async () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin(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(DetectionPlugin(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(DetectionPlugin(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 throw error when no avaliableLanguages are set', () => {
+    tolgee = Tolgee().use(DetectionPlugin('en')).init({
+      defaultLanguage: 'es',
+    });
+
+    expect(() => tolgee.run()).toThrow();
+  });
+
+  it('will throw error when no defaultLanguage specified', () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin('en'))
+      .init({
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+
+    expect(() => tolgee.run()).toThrow(/'defaultLanguage'/);
+  });
+
+  it('will throw error when no available languages specified', () => {
+    tolgee = Tolgee().use(DetectionPlugin('en')).init({});
+
+    expect(() => tolgee.run()).toThrow(/'availableLanguages'/);
+  });
+});