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

package/src/wrappers/text/Coder.test.ts

@@ -1,298 +0,0 @@
-jest.dontMock('./Coder');
-jest.dontMock('../../services/DependencyService');
-jest.dontMock('../../helpers/TextHelper');
-jest.dontMock('../../services/TextService');
-jest.dontMock('../../services/ModuleService');
-jest.dontMock('../../modules/IcuFormatter');
-
-import { DependencyService } from '../../services/DependencyService';
-import { Coder } from './Coder';
-import { getMockedInstance } from '@testFixtures/mocked';
-import { TextService } from '../../services/TextService';
-import { Properties } from '../../Properties';
-import { TranslationService } from '../../services/TranslationService';
-import { IcuFormatter } from '../../modules/IcuFormatter';
-
-describe('Coder', () => {
-  let mockedTranslationReturn = '';
-  let textService: TextService;
-  let coder: Coder;
-
-  const getTranslationMock = jest.fn(async () => {
-    return mockedTranslationReturn;
-  });
-
-  const getFromCacheOrCallbackMock = jest.fn(() => {
-    return mockedTranslationReturn;
-  });
-
-  beforeEach(async () => {
-    const depStore = new DependencyService();
-    depStore.moduleService.addModule(IcuFormatter);
-    depStore.run();
-    textService = depStore.textService;
-    mockedTranslationReturn = 'Dummy translated text {param1} {param2}';
-
-    coder = new Coder(depStore.properties, textService);
-
-    getMockedInstance(Properties).config = {
-      inputPrefix: '{{',
-      inputSuffix: '}}',
-      restrictedElements: [],
-      tagAttributes: {
-        '*': ['aria-label'],
-      },
-    };
-    getMockedInstance(TranslationService).getTranslation = getTranslationMock;
-
-    getMockedInstance(TranslationService).getFromCacheOrFallback =
-      getFromCacheOrCallbackMock;
-  });
-
-  afterEach(async () => {
-    jest.clearAllMocks();
-  });
-
-  test('replace function replaces occurrences correctly', async () => {
-    const text =
-      'This is text with params {{text:param1:hello,param2:hello 2 as well}}. Text continues';
-    const replaced = await coder.unwrap(text);
-    expect(replaced.text).toEqual(
-      'This is text with params Dummy translated text hello hello 2 as well. Text continues'
-    );
-    expect(replaced.keys[0].key).toEqual('text');
-    expect(replaced.keys[0].params['param1']).toEqual('hello');
-    expect(replaced.keys[0].params['param2']).toEqual('hello 2 as well');
-  });
-
-  test('replace function does not replace when prefix is escaped', async () => {
-    const text = 'This is text: {{text:param1:aaaa,param2:aaaa}} \\{{text}}';
-    const replaced = await coder.unwrap(text);
-    expect(replaced.text).toEqual(
-      'This is text: Dummy translated text aaaa aaaa {{text}}'
-    );
-  });
-
-  test("it doesn't affect not related backslashes", async () => {
-    const text =
-      '\\This is \\text: {{text:param1:aaaa,param2:aaaa}} \\{{text}}, see? \\';
-    const replaced = await coder.unwrap(text);
-    expect(replaced.text).toEqual(
-      '\\This is \\text: Dummy translated text aaaa aaaa {{text}}, see? \\'
-    );
-  });
-
-  test('correctly parses default value', async () => {
-    const text =
-      '\\This is \\text: {{text,This is my default value.\\:look!:param1:aaaa,param2:aaaa}} \\{{text}}, see? \\';
-    await coder.unwrap(text);
-    expect(getFromCacheOrCallbackMock).toHaveBeenCalledWith(
-      'text',
-      undefined,
-      'This is my default value.:look!'
-    );
-  });
-
-  test('replace function does not translate when params have escaped , or :', async () => {
-    const text =
-      'This is text: {{text:param1:param 1 with\\,and \\:.,param2:hello \\:}}. Text continues';
-    const replaced = await coder.unwrap(text);
-    expect(replaced.text).toEqual(
-      'This is text: Dummy translated text param 1 with,and :. hello :. Text continues'
-    );
-  });
-
-  test('replace function does not translate when params have escaped \\', async () => {
-    const text =
-      'This is text: {{text:param1:param 1 with\\\\ and again \\\\,param2:hello \\\\}}. Text continues';
-    const replaced = await coder.unwrap(text);
-    expect(replaced.text).toEqual(
-      'This is text: Dummy translated text param 1 with\\ and again \\ hello \\. Text continues'
-    );
-  });
-
-  test('replace function works with new lines in key', async () => {
-    mockedTranslationReturn = 'yep';
-    const text = 'This is text: {{text\nwith\nnew\nlines}}. Text continues';
-    await coder.unwrap(text);
-    expect(getFromCacheOrCallbackMock).toHaveBeenCalledWith(
-      'text\nwith\nnew\nlines',
-      undefined,
-      undefined
-    );
-  });
-
-  test('works with escaped strings in params', async () => {
-    const text = 'Text: {{text\nwith\nnew\nlines:hello:w\\,or\\:ld}}.';
-    mockedTranslationReturn = 'translated {hello}';
-    const result = await coder.unwrap(text);
-    expect(result.keys[0].params['hello']).toEqual('w,or:ld');
-  });
-
-  describe('Different key occurrences', () => {
-    beforeEach(() => {
-      getMockedInstance(TranslationService).getFromCacheOrFallback = jest.fn(
-        () => {
-          return 'translated';
-        }
-      );
-    });
-
-    test('longer text will be handled correctly', async () => {
-      const text =
-        'This is standard text to translate: {{text}}. This is another one: {{text}}.\n' +
-        'There is an text with slash before, but escaped: \\\\{{text}}\n' +
-        'This is one with escaped prefix, to it shall not translate this one: \\{{aaa}}\n' +
-        'There is another text: {{text}}\n' +
-        'There are two texts to translate next to each other: {{text}}{{text}}. And after it text continues: {{text}}.\n' +
-        'This is an end, finally.\n';
-
-      const replaced = await coder.unwrap(text);
-
-      expect(replaced.text).toEqual(
-        'This is standard text to translate: translated. This is another one: translated.\n' +
-          'There is an text with slash before, but escaped: \\translated\n' +
-          'This is one with escaped prefix, to it shall not translate this one: {{aaa}}\n' +
-          'There is another text: translated\n' +
-          'There are two texts to translate next to each other: translatedtranslated. And after it text continues: translated.\n' +
-          'This is an end, finally.\n'
-      );
-    });
-
-    test('will translate correctly when the text begins with key', async () => {
-      const text = '{{text}}, text continues';
-      const replaced = await coder.unwrap(text);
-      expect(replaced.text).toEqual('translated, text continues');
-    });
-
-    test('will not translate when there is nothing to translate', async () => {
-      const text = '\\{{text}}, text continues';
-      const replaced = await coder.unwrap(text);
-      expect(replaced).toEqual(undefined);
-    });
-
-    test('will not translate when the text begins with escaped key', async () => {
-      const text = '\\{{text}}, text continues {{other text}}';
-      const replaced = await coder.unwrap(text);
-      expect(replaced.text).toEqual('{{text}}, text continues translated');
-    });
-
-    test('will translate when the text begins with escaped escape character', async () => {
-      const text = '\\\\{{text}}, text continues {{other text}}';
-      const replaced = await coder.unwrap(text);
-      expect(replaced.text).toEqual('\\translated, text continues translated');
-    });
-
-    test('will translate when the text begins with escaped escape character, what is escaped', async () => {
-      const text = '\\\\\\{{text}}, text continues {{other text}}';
-      const replaced = await coder.unwrap(text);
-      expect(replaced.text).toEqual('\\\\{{text}}, text continues translated');
-    });
-  });
-
-  describe('wrap function', () => {
-    test('will correctly wrap text without params', () => {
-      expect(coder.wrap('text')).toEqual('{{text}}');
-    });
-
-    test('will correctly wrap text with , and :', () => {
-      expect(coder.wrap('text, other text: yes!')).toEqual(
-        '{{text\\, other text\\: yes!}}'
-      );
-    });
-
-    test('will correctly wrap text with ,, : and \\', () => {
-      expect(coder.wrap('text, other text: \\ yes!')).toEqual(
-        '{{text\\, other text\\: \\\\ yes!}}'
-      );
-    });
-
-    test('will correctly wrap text with parameters', () => {
-      expect(
-        coder.wrap('text', {
-          param1: 'the param value',
-          param2: '2nd value',
-        })
-      ).toEqual('{{text:param1:the param value,param2:2nd value}}');
-    });
-
-    test('will correctly wrap text with parameters containing : an ,', () => {
-      expect(
-        coder.wrap('text', {
-          param1: 'the param value: value, value2 or value3',
-          param2: '2nd value',
-        })
-      ).toEqual(
-        '{{text:param1:the param value\\: value\\, value2 or value3,param2:2nd value}}'
-      );
-    });
-
-    test('it will correctly replace wrapped text', async () => {
-      getMockedInstance(TranslationService).getFromCacheOrFallback = jest.fn(
-        () => {
-          return 'xxx {param1} {param2} xxx';
-        }
-      );
-
-      const wrapped = coder.wrap(
-        'An longer key with some strange ,: ,: \\ characters',
-        { param1: ',:,:', param2: '....\\...,' }
-      );
-
-      expect((await coder.unwrap(wrapped)).text).toEqual(
-        'xxx ,:,: ....\\..., xxx'
-      );
-    });
-
-    test('will correctly convert param to string', () => {
-      const wrapped = coder.wrap('key', { param1: 1 });
-      expect(wrapped).toEqual('{{key:param1:1}}');
-    });
-
-    test('will correctly replace number parameters', async () => {
-      getMockedInstance(TranslationService).getFromCacheOrFallback = jest.fn(
-        () => {
-          return 'xxx {param1, number} {param2, number} xxx';
-        }
-      );
-
-      const wrapped = coder.wrap('key', { param1: 1, param2: 145.5 });
-      expect((await coder.unwrap(wrapped)).text).toEqual('xxx 1 145.5 xxx');
-    });
-
-    test('correctly wraps default value', async () => {
-      const wrapped = coder.wrap(
-        'key',
-        { param1: 1, param2: 'Yes,yes,yes:yes' },
-        'Look: What a beautiful default\nvalue,' +
-          ' translating will be such an experience.'
-      );
-      expect(wrapped).toEqual(
-        '{{key,Look\\: What a beautiful default\n' +
-          'value\\, translating will be such an experience.' +
-          ':param1:1,param2:Yes\\,yes\\,yes\\:yes}}'
-      );
-
-      await coder.unwrap(wrapped);
-      expect(getFromCacheOrCallbackMock).toBeCalledWith(
-        'key',
-        undefined,
-        'Look: What a beautiful default\nvalue, translating will be such an experience.'
-      );
-    });
-
-    test('will correctly replace bigint parameter', async () => {
-      getMockedInstance(TranslationService).getFromCacheOrFallback = jest.fn(
-        () => {
-          return 'xxx {param1, number} {param2, number} xxx';
-        }
-      );
-
-      const wrapped = coder.wrap('key', {
-        param1: 1,
-        param2: BigInt(129374),
-      });
-      expect((await coder.unwrap(wrapped)).text).toEqual('xxx 1 129,374 xxx');
-    });
-  });
-});

package/src/wrappers/text/Coder.ts

@@ -1,202 +0,0 @@
-import { TextHelper } from '../../helpers/TextHelper';
-import { Properties } from '../../Properties';
-import { TextService } from '../../services/TextService';
-import {
-  KeyAndParams,
-  KeyAndParamsTags,
-  TranslatedWithMetadataTags,
-  TranslationParams,
-  Unwrapped,
-} from '../../types';
-
-export class Coder {
-  constructor(
-    private properties: Properties,
-    private textService: TextService
-  ) {}
-
-  private get rawUnWrapRegex(): string {
-    const escapedPrefix = this.escapeForRegExp(
-      this.properties.config.inputPrefix
-    );
-    const escapedSuffix = this.escapeForRegExp(
-      this.properties.config.inputSuffix
-    );
-    return `(\\\\?)(${escapedPrefix}(.*?)${escapedSuffix})`;
-  }
-
-  private static parseUnwrapped(unwrappedString: string): KeyAndParams {
-    let escaped = false;
-    let actual = '';
-    let paramName = '';
-    let readingState: 'KEY' | 'DEFAULT_VALUE' | 'PARAM_NAME' | 'PARAM_VALUE' =
-      'KEY';
-
-    const result = {
-      key: '',
-      params: {},
-      defaultValue: undefined as string | undefined,
-    } as KeyAndParams;
-
-    for (const char of unwrappedString) {
-      if (char === '\\' && !escaped) {
-        escaped = true;
-        continue;
-      }
-      if (escaped) {
-        escaped = false;
-        actual += char;
-        continue;
-      }
-      if (readingState === 'KEY' && char === ',') {
-        readingState = 'DEFAULT_VALUE';
-        result.key = actual;
-        actual = '';
-        continue;
-      }
-
-      if (readingState === 'KEY' && char === ':') {
-        readingState = 'PARAM_NAME';
-        result.key = actual;
-        actual = '';
-        continue;
-      }
-
-      if (readingState === 'DEFAULT_VALUE' && char === ':') {
-        readingState = 'PARAM_NAME';
-        result.defaultValue = actual;
-        actual = '';
-        continue;
-      }
-
-      if (readingState === 'PARAM_NAME' && char === ':') {
-        readingState = 'PARAM_VALUE';
-        paramName = actual;
-        actual = '';
-        continue;
-      }
-
-      if (readingState === 'PARAM_VALUE' && char === ',') {
-        readingState = 'PARAM_NAME';
-        result.params[paramName] = actual;
-        actual = '';
-        continue;
-      }
-      actual += char;
-    }
-
-    if (readingState === 'KEY') {
-      result.key = actual;
-    }
-
-    if (readingState === 'DEFAULT_VALUE') {
-      result.defaultValue = actual;
-    }
-
-    if (readingState === 'PARAM_VALUE') {
-      result.params[paramName] = actual;
-    }
-
-    return result;
-  }
-
-  unwrap(text: string): Unwrapped {
-    const matchRegexp = new RegExp(this.rawUnWrapRegex, 'gs');
-
-    const keysAndParams: KeyAndParamsTags<any>[] = [];
-
-    let matched = false;
-
-    let match;
-    let start = 0;
-    let result = '';
-    while ((match = matchRegexp.exec(text)) !== null) {
-      let pre = match[1] as string;
-      const [fullMatch, _, wrapped, unwrapped] = match as [
-        string,
-        string,
-        string,
-        string
-      ];
-      const { index, input } = match;
-      result += input.substr(start, index - start);
-      start = index + fullMatch.length;
-      if (pre === '\\') {
-        if (!TextHelper.isCharEscaped(index, text)) {
-          result += wrapped;
-          continue;
-        }
-        pre = '';
-      }
-      const translated = this.getTranslatedWithMetadata(unwrapped);
-      keysAndParams.push({
-        key: translated.key,
-        params: translated.params,
-        defaultValue: translated.defaultValue,
-      });
-      matched = true;
-      result += pre + translated.translated;
-    }
-
-    result += text.substring(start);
-
-    if (matched) {
-      return { text: result, keys: keysAndParams };
-    }
-
-    return undefined;
-  }
-
-  public wrap(
-    key: string,
-    params: TranslationParams = {},
-    defaultValue: string | undefined = undefined
-  ): string {
-    let paramString = Object.entries(params)
-      .map(
-        ([name, value]) =>
-          `${this.escapeParam(name)}:${this.escapeParam(value as string)}`
-      )
-      .join(',');
-    paramString = paramString.length ? `:${paramString}` : '';
-
-    const defaultString =
-      defaultValue !== undefined ? `,${this.escapeParam(defaultValue)}` : '';
-
-    return `${this.properties.config.inputPrefix}${this.escapeParam(
-      key
-    )}${defaultString}${paramString}${this.properties.config.inputSuffix}`;
-  }
-
-  private getTranslatedWithMetadata(
-    text: string
-  ): TranslatedWithMetadataTags<any> {
-    const { key, params, defaultValue } = Coder.parseUnwrapped(text);
-    const translated = this.textService.instant(
-      key,
-      params,
-      undefined,
-      false,
-      defaultValue
-    );
-    return { translated, key, params, defaultValue };
-  }
-
-  private readonly escapeForRegExp = (string: string) => {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  };
-
-  private readonly escapeParam = (param: any) => {
-    if (typeof param === 'string') {
-      return param.replace(/[,:\\]/gs, '\\$&');
-    }
-    if (typeof param === 'number' || typeof param === 'bigint') {
-      return param.toString();
-    }
-    // eslint-disable-next-line no-console
-    console.warn(
-      `Parameters of type "${typeof param}" are not supported in "text" wrapper mode.`
-    );
-    return param;
-  };
-}

package/src/wrappers/text/ContentHandler.test.ts

@@ -1,185 +0,0 @@
-jest.dontMock('./ContentHandler');
-jest.dontMock('./TextWrapper');
-jest.dontMock('../NodeHandler');
-jest.dontMock('../../services/EventService');
-jest.dontMock('../../helpers/NodeHelper.ts');
-jest.dontMock('../../services/DependencyService');
-
-import { ContentHandler } from './ContentHandler';
-import '@testing-library/jest-dom/extend-expect';
-import { ElementWithMeta, NodeWithMeta, Unwrapped } from '../../types';
-import { NodeHelper } from '../../helpers/NodeHelper';
-import { createTestDom } from '@testFixtures/createTestDom';
-import { getMockedInstance } from '@testFixtures/mocked';
-import { ElementRegistrar } from '../../services/ElementRegistrar';
-import { Properties } from '../../Properties';
-import { DependencyService } from '../../services/DependencyService';
-import { Coder } from './Coder';
-import { TextWrapper } from './TextWrapper';
-
-describe('TextHandler', () => {
-  let textHandler: ContentHandler;
-
-  const mockedKeys = [
-    {
-      key: 'dummyKey',
-      params: { dummyParam: 'dummyValue' },
-    },
-  ];
-
-  const mockedTranslateInner = (text) => {
-    return {
-      text: text.replace(/{{(.*?)}}/gs, 'translated $1'),
-      keys: mockedKeys,
-    } as Unwrapped;
-  };
-
-  const gv = (key) => mockedTranslateInner(key).text;
-  const mockedTranslate = jest.fn(mockedTranslateInner);
-  let c: ReturnType<typeof createTestDom>;
-  beforeEach(() => {
-    const dependencyService = new DependencyService();
-    dependencyService.init({});
-
-    // @ts-ignore
-    textHandler = (dependencyService.wrapper as TextWrapper).textHandler;
-    getMockedInstance(Properties).config = {
-      inputPrefix: '{{',
-      inputSuffix: '}}',
-      restrictedElements: [],
-      tagAttributes: {
-        '*': ['aria-label'],
-      },
-      passToParent: ['option'],
-    };
-    c = createTestDom(document);
-    getMockedInstance(Coder).unwrap = (...args) => mockedTranslate(...args);
-  });
-
-  afterEach(async () => {
-    jest.clearAllMocks();
-  });
-
-  describe('in production mode', () => {
-    beforeEach(async () => {
-      await textHandler.handle(document.body);
-    });
-
-    test('Can be created', () => {
-      expect(textHandler).not.toBeUndefined();
-    });
-
-    test('will handle text in root', async () => {
-      expect(`./text()[contains(., ${gv(c.keyInRoot)})]`).toBeFoundIn(
-        document.body
-      );
-    });
-
-    test('will handle text in div', async () => {
-      expect(
-        `./div/text()[contains(., 'Some trash... translated ${gv(
-          c.keyInRootDiv
-        )}')]`
-      ).toBeFoundIn(document.body);
-    });
-
-    test('will handle text in div > div > span', async () => {
-      const xpath = `./div/div/span/text()[contains(., 'translated ${gv(
-        c.hereKey
-      )} and translated ${gv(c.hereTooKey)}')]`;
-      expect(xpath).toBeFoundIn(document.body);
-    });
-
-    describe("Node's _tolgee property", () => {
-      let node: NodeWithMeta;
-
-      beforeEach(() => {
-        node = NodeHelper.evaluateToSingle(
-          `./text()[contains(., ${gv(c.keyInRoot)})]`,
-          document.body
-        ) as NodeWithMeta;
-      });
-
-      test('will be defined', () => {
-        expect(node._tolgee).toBeDefined();
-      });
-
-      test('will have proper oldTextContent', () => {
-        expect(node._tolgee.oldTextContent).toContain(`{{${c.keyInRoot}}}`);
-      });
-
-      test('will have proper keys length', () => {
-        expect(node._tolgee.keys).toHaveLength(1);
-      });
-
-      test('will have proper first key', () => {
-        expect(node._tolgee.keys).toEqual(mockedKeys);
-      });
-    });
-
-    describe("Parent element's _tolgee property and attribute", () => {
-      let element: ElementWithMeta;
-      let node: NodeWithMeta;
-
-      beforeEach(() => {
-        node = NodeHelper.evaluateToSingle(
-          `./text()[contains(., ${gv(c.keyInRoot)})]`,
-          document.body
-        );
-        element = node.parentElement as any as ElementWithMeta;
-      });
-
-      test('property will be defined', () => {
-        expect(element._tolgee).toBeDefined();
-      });
-
-      test('will contain nodes array with correct node', () => {
-        expect(element._tolgee.nodes).toEqual(new Set([node]));
-      });
-
-      test('attribute will be set', () => {
-        expect(element.getAttribute('_tolgee')).toEqual('');
-      });
-    });
-
-    test("will pass option's text node to select element", () => {
-      const xPath = `//text()[contains(., 'translated option_key')]`;
-      const node = NodeHelper.evaluateToSingle(xPath, document.body);
-      expect(node.parentElement.parentElement).toHaveAttribute('_tolgee', '');
-      expect(node.parentElement).not.toHaveAttribute('_tolgee');
-    });
-  });
-
-  test('will pass recursively', async () => {
-    getMockedInstance(Properties).config.passToParent = ['option', 'select'];
-    await textHandler.handle(document.body);
-    const xPath = `//text()[contains(., 'translated option_key')]`;
-    const node = NodeHelper.evaluateToSingle(xPath, document.body);
-    expect(node.parentElement.parentElement.parentElement).toHaveAttribute(
-      '_tolgee',
-      ''
-    );
-    expect(node.parentElement.parentElement).not.toHaveAttribute('_tolgee');
-  });
-
-  test('will pass with function', async () => {
-    getMockedInstance(Properties).config.passToParent = (element) =>
-      element.tagName === 'OPTION';
-    await textHandler.handle(document.body);
-    const xPath = `//text()[contains(., 'translated option_key')]`;
-    const node = NodeHelper.evaluateToSingle(xPath, document.body);
-    expect(node.parentElement.parentElement).toHaveAttribute('_tolgee', '');
-    expect(node.parentElement).not.toHaveAttribute('_tolgee');
-  });
-
-  test('will register the node', async () => {
-    await textHandler.handle(document.body);
-    const node = NodeHelper.evaluateToSingle(
-      `./text()[contains(., ${gv(c.keyInRoot)})]`,
-      document.body
-    );
-    expect(getMockedInstance(ElementRegistrar).register).toBeCalledWith(
-      node.parentElement
-    );
-  });
-});

package/src/wrappers/text/ContentHandler.ts

@@ -1,21 +0,0 @@
-import { NodeHelper } from '../../helpers/NodeHelper';
-import { Properties } from '../../Properties';
-import { NodeHandler } from '../NodeHandler';
-
-export class ContentHandler {
-  constructor(
-    private properties: Properties,
-    private nodeHandler: NodeHandler
-  ) {}
-
-  async handle(node: Node): Promise<void> {
-    const inputPrefix = this.properties.config.inputPrefix;
-    const inputSuffix = this.properties.config.inputSuffix;
-
-    const xPath = `./descendant-or-self::text()[contains(., '${inputPrefix}') and contains(., '${inputSuffix}')]`;
-    const nodes = NodeHelper.evaluate(xPath, node);
-    const filtered: Text[] = this.nodeHandler.filterRestricted(nodes as Text[]);
-
-    await this.nodeHandler.handleNodes(filtered);
-  }
-}