@tolgee/core 4.7.0 → 4.7.2

package/src/wrappers/text/AttributeHandler.ts

@@ -0,0 +1,25 @@
+import { NodeHandler } from '../NodeHandler';
+import { Properties } from '../../Properties';
+import { NodeHelper } from '../../helpers/NodeHelper';
+
+export class AttributeHandler {
+  constructor(
+    private properties: Properties,
+    private nodeHandler: NodeHandler
+  ) {}
+
+  async handle(node: Element) {
+    const inputPrefix = this.properties.config.inputPrefix;
+    const inputSuffix = this.properties.config.inputSuffix;
+
+    for (const [tag, attributes] of Object.entries(
+      this.properties.config.tagAttributes
+    )) {
+      for (const attribute of attributes) {
+        const expression = `descendant-or-self::${tag}/@${attribute}[contains(., '${inputPrefix}') and contains(., '${inputSuffix}')]`;
+        const nodes: Array<Attr | Text> = NodeHelper.evaluate(expression, node);
+        await this.nodeHandler.handleNodes(nodes);
+      }
+    }
+  }
+}

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

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

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