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

package/src/services/TextService.ts

@@ -1,82 +0,0 @@
-import { TranslationTags, TranslationParamsTags } from '../types';
-import { TranslationService } from './TranslationService';
-import { Properties } from '../Properties';
-import { ModuleService } from './ModuleService';
-
-export class TextService {
-  constructor(
-    private properties: Properties,
-    private translationService: TranslationService,
-    private moduleService: ModuleService
-  ) {}
-
-  async translate(
-    key: string,
-    params: TranslationParamsTags<any>,
-    lang = this.properties.currentLanguage,
-    orEmpty?: boolean,
-    defaultValue?: string
-  ) {
-    const translation = await this.translationService.getTranslation(
-      key,
-      lang,
-      defaultValue
-    );
-    return this.formatTranslation(key, translation, params, lang, orEmpty);
-  }
-
-  instant(
-    key: string,
-    params: TranslationParamsTags<any>,
-    lang = this.properties.currentLanguage,
-    orEmpty?: boolean,
-    defaultValue?: string
-  ) {
-    const translation = this.translationService.getFromCacheOrFallback(
-      key,
-      lang,
-      defaultValue
-    );
-
-    return this.formatTranslation(key, translation, params, lang, orEmpty);
-  }
-
-  private formatTranslation(
-    key: string,
-    translation: string | undefined,
-    params: TranslationParamsTags<any> | undefined,
-    lang: string | undefined,
-    orEmpty: boolean | undefined
-  ) {
-    if (translation !== undefined) {
-      return this.format(translation, params, lang);
-    }
-    if (!orEmpty) {
-      return key;
-    }
-    return '';
-  }
-
-  private readonly format = (
-    translation: string,
-    params: TranslationParamsTags<any>,
-    lang: string | undefined
-  ): TranslationTags<any> => {
-    try {
-      // try to format the text
-      let result: TranslationTags<any> = translation;
-      if (this.moduleService.formatter) {
-        result = this.moduleService.formatter.format({
-          translation: result,
-          params,
-          language: lang || this.properties.currentLanguage,
-        });
-      }
-      return result as TranslationTags<any>;
-    } catch (e) {
-      // if string cannot be formatted, throw error
-      // eslint-disable-next-line no-console
-      console.error(e);
-    }
-  };
-}

package/src/services/TranslationService.test.ts

@@ -1,358 +0,0 @@
-jest.dontMock('./TranslationService');
-jest.dontMock('../helpers/TextHelper');
-jest.dontMock('../types/DTOs');
-jest.dontMock('../Errors/ApiHttpError');
-jest.dontMock('./DependencyService');
-
-import { TranslationService } from './TranslationService';
-import { getMockedInstance } from '@testFixtures/mocked';
-import { ApiHttpService } from './ApiHttpService';
-import { Properties } from '../Properties';
-import { CoreService } from './CoreService';
-import { TranslationData } from '../types/DTOs';
-import { ApiHttpError } from '../Errors/ApiHttpError';
-import { EventService } from './EventService';
-import { DependencyService } from './DependencyService';
-
-const mockedTranslations = {
-  en: {
-    key: 'translated',
-    'translation.with.dots': 'Translation with dots',
-    structured: {
-      subtree: {
-        translation: 'Structured subtree translation',
-      },
-    },
-    'key with: \\\\': {
-      t: 'Key with strange escapes',
-    },
-    just_en: 'Just en.',
-  },
-  de: {
-    key: 'übersetzen',
-    just_en: '',
-  },
-};
-
-global.fetch = jest.fn(async (url: string) => {
-  const isEn = url.indexOf('en.json') > -1;
-  const isDe = url.indexOf('de.json') > -1;
-
-  return {
-    json: jest.fn(async () =>
-      isEn ? mockedTranslations.en : isDe ? mockedTranslations.de : {}
-    ),
-  };
-}) as any;
-
-describe('TranslationService', () => {
-  let translationService: TranslationService;
-  const languageLoadedEmitMock = jest.fn();
-  const translationChangedEmitMock = jest.fn();
-
-  beforeEach(async () => {
-    const dependencyService = new DependencyService();
-    dependencyService.init({});
-    translationService = dependencyService.translationService;
-    (getMockedInstance(EventService) as any).LANGUAGE_LOADED = {
-      emit: languageLoadedEmitMock,
-    };
-    (getMockedInstance(EventService) as any).TRANSLATION_CHANGED = {
-      emit: translationChangedEmitMock,
-    };
-    getMockedInstance(ApiHttpService).fetchJson = jest.fn(
-      async () => mockedTranslations
-    );
-    getMockedInstance(Properties).currentLanguage = 'en';
-  });
-
-  afterEach(async () => {
-    jest.clearAllMocks();
-  });
-
-  describe('(translation loading and retrieval)', () => {
-    test('will load translations in production mode', async () => {
-      await translationService.loadTranslations('en');
-      expect(translationService.getFromCacheOrFallback('key', 'en')).toEqual(
-        'translated'
-      );
-    });
-
-    test('will load translations in development mode', async () => {
-      getMockedInstance(Properties).mode = 'development';
-      await translationService.loadTranslations('en');
-      expect(translationService.getFromCacheOrFallback('key', 'en')).toEqual(
-        'translated'
-      );
-    });
-
-    test('will try to load the languages only single time', async () => {
-      await translationService.loadTranslations('en');
-      await translationService.loadTranslations('en');
-      expect(fetch).toBeCalledTimes(1);
-    });
-
-    test('will get proper translation', async () => {
-      expect(await translationService.getTranslation('key', 'en')).toEqual(
-        'translated'
-      );
-    });
-
-    test('will get proper translation containing .', async () => {
-      expect(
-        await translationService.getTranslation('translation.with.dots')
-      ).toEqual('Translation with dots');
-    });
-
-    test('will get proper structured subtree translation', async () => {
-      expect(
-        await translationService.getTranslation(
-          'structured.subtree.translation'
-        )
-      ).toEqual('Structured subtree translation');
-    });
-
-    test('will get proper translation on strange key', async () => {
-      expect(
-        await translationService.getTranslation('key with: \\\\.t')
-      ).toEqual('Key with strange escapes');
-    });
-
-    test('will return fallback lang translation', async () => {
-      expect(await translationService.getTranslation('key', 'cz')).toEqual(
-        'translated'
-      );
-    });
-
-    test('will get translations of key', async () => {
-      getMockedInstance(ApiHttpService).fetchJson = jest.fn(async () => ({
-        _embedded: {
-          keys: [
-            {
-              translations: {
-                en: { text: 'translated' },
-                de: { text: 'übersetzen' },
-              },
-            },
-          ],
-        },
-      }));
-      const [translationData] = await translationService.getTranslationsOfKey(
-        'key',
-        new Set<string>(['en', 'de'])
-      );
-      expect(translationData).toEqual({
-        translations: {
-          en: { text: 'translated' },
-          de: { text: 'übersetzen' },
-        },
-      });
-    });
-
-    test('will reset preferred languages when language is not found', async () => {
-      global['apierror'] = ApiHttpError;
-      getMockedInstance(ApiHttpService).fetchJson = jest.fn(async () => {
-        throw new ApiHttpError(
-          { status: 404 } as Response,
-          'language_not_found'
-        );
-      });
-
-      delete global.location;
-      global.location = { reload: jest.fn() } as any;
-      global.console.error = jest.fn();
-      getMockedInstance(CoreService).getLanguages = jest.fn(
-        async () => new Set(['dummyLang'])
-      );
-      await translationService.getTranslationsOfKey('aaa', new Set<string>());
-      expect(getMockedInstance(Properties).preferredLanguages).toEqual(
-        new Set(['dummyLang'])
-      );
-      // eslint-disable-next-line no-console
-      expect(console.error).toBeCalledTimes(1);
-      expect(location.reload).toBeCalledTimes(1);
-    });
-
-    test('will emit on translations load', async () => {
-      await translationService.loadTranslations('en');
-      await translationService.loadTranslations('de');
-      await translationService.loadTranslations('en');
-
-      expect(languageLoadedEmitMock).toBeCalledTimes(2);
-      expect(languageLoadedEmitMock).toHaveBeenNthCalledWith(1, 'en');
-      expect(languageLoadedEmitMock).toHaveBeenNthCalledWith(2, 'de');
-    });
-
-    test("won't throw exception when there is null in translation data", async () => {
-      getMockedInstance(Properties).mode = 'development';
-      getMockedInstance(ApiHttpService).fetchJson = jest.fn(async () => ({
-        en: {
-          hello: null,
-          yep: 'Load was successfull.',
-        },
-      }));
-      window.console.error = jest.fn();
-      await translationService.loadTranslations('en');
-      expect(window.console.error).toHaveBeenCalledTimes(0);
-      expect(translationService.getFromCacheOrFallback('yep')).toEqual(
-        'Load was successfull.'
-      );
-    });
-
-    describe('set translation', () => {
-      const dummyTranslationData = {
-        key: 'test key',
-        translations: { en: 'translation' },
-      } as TranslationData;
-
-      beforeEach(async () => {
-        getMockedInstance(ApiHttpService).postJson = jest.fn(async () => {
-          return {
-            keyId: undefined,
-            keyName: 'test key',
-            translations: {
-              en: {
-                text: 'translation',
-              },
-            },
-          };
-        });
-        await translationService.setTranslations(dummyTranslationData);
-      });
-
-      test('will call the api http service', async () => {
-        expect(getMockedInstance(ApiHttpService).postJson).toBeCalledTimes(1);
-        expect(getMockedInstance(ApiHttpService).postJson).toBeCalledWith(
-          'v2/projects/translations',
-          dummyTranslationData
-        );
-      });
-
-      test('will check the scopes', async () => {
-        expect(getMockedInstance(CoreService).checkScope).toBeCalledTimes(1);
-      });
-
-      test('emits translation changed event', async () => {
-        expect(translationChangedEmitMock).toBeCalledTimes(1);
-        expect(translationChangedEmitMock).toBeCalledWith(dummyTranslationData);
-      });
-
-      test('will update the data', async () => {
-        await translationService.loadTranslations('en');
-        await translationService.setTranslations(dummyTranslationData);
-        expect(
-          await translationService.getTranslation(
-            dummyTranslationData.key,
-            'en'
-          )
-        ).toEqual(dummyTranslationData.translations.en);
-      });
-    });
-
-    test('will update the data when the key contains .', async () => {
-      const dummyTranslationData = {
-        key: 'test.key',
-        translations: { en: 'translation' },
-      } as TranslationData;
-      getMockedInstance(ApiHttpService).postJson = jest.fn(async () => {
-        return {
-          keyId: undefined,
-          keyName: 'test.key',
-          translations: {
-            en: {
-              text: 'translation',
-            },
-          },
-        };
-      });
-      await translationService.loadTranslations('en');
-      await translationService.setTranslations(dummyTranslationData);
-      expect(
-        await translationService.getTranslation(dummyTranslationData.key, 'en')
-      ).toEqual(dummyTranslationData.translations.en);
-    });
-
-    test('will update the data when the key contains \\.', async () => {
-      const dummyTranslationData = {
-        key: 'test\\.key',
-        translations: { en: 'translation' },
-      } as TranslationData;
-      getMockedInstance(ApiHttpService).postJson = jest.fn(async () => {
-        return {
-          keyId: undefined,
-          keyName: 'test\\.key',
-          translations: {
-            en: {
-              text: 'translation',
-            },
-          },
-        };
-      });
-      await translationService.loadTranslations('en');
-      await translationService.setTranslations(dummyTranslationData);
-      expect(
-        await translationService.getTranslation(dummyTranslationData.key, 'en')
-      ).toEqual(dummyTranslationData.translations.en);
-    });
-
-    test('will call load of fallback language on missing translation', async () => {
-      translationService.loadTranslations = jest.fn();
-      getMockedInstance(Properties).config.fallbackLanguage = 'en';
-      expect(await translationService.getTranslation('aaa', 'cs'));
-      expect(translationService.loadTranslations).toBeCalledTimes(2);
-      expect(translationService.loadTranslations).toBeCalledWith('cs');
-      expect(translationService.loadTranslations).toBeCalledWith('en');
-    });
-
-    test('will use fallback language on missing translation', async () => {
-      getMockedInstance(Properties).config.fallbackLanguage = 'en';
-      expect(
-        await translationService.getTranslation('translation.with.dots', 'de')
-      ).toEqual('Translation with dots');
-    });
-
-    test('getTranslation will return fallback when message is empty string', async () => {
-      getMockedInstance(Properties).config.fallbackLanguage = 'en';
-      expect(await translationService.getTranslation('just_en', 'de')).toEqual(
-        'Just en.'
-      );
-    });
-
-    test('getFromCacheOrCallback will return fallback when message is empty string', async () => {
-      getMockedInstance(Properties).config.fallbackLanguage = 'en';
-      (translationService as any).setLanguageData('en', mockedTranslations.en);
-      (translationService as any).setLanguageData('de', mockedTranslations.de);
-      expect(
-        await translationService.getFromCacheOrFallback('just_en', 'de')
-      ).toEqual('Just en.');
-    });
-
-    test('uses provided static data', async () => {
-      getMockedInstance(Properties).config.staticData = {
-        en: { test: 'Test test' },
-      };
-      translationService.initStatic();
-      expect(await translationService.getTranslation('test', 'en')).toEqual(
-        'Test test'
-      );
-    });
-
-    test('uses provided promise data', async () => {
-      getMockedInstance(Properties).config.staticData = {
-        en: () => new Promise((resolve) => resolve({ test: 'Test test' })),
-      };
-      expect(await translationService.getTranslation('test', 'en')).toEqual(
-        'Test test'
-      );
-    });
-
-    test('uses provided data without init static (when mode is changed dynamically)', async () => {
-      getMockedInstance(Properties).config.staticData = {
-        en: { test: 'Test test' },
-      };
-      expect(await translationService.getTranslation('test', 'en')).toEqual(
-        'Test test'
-      );
-    });
-  });
-});