@tolgee/core 4.9.2 → 4.9.3-rc.23424f3.0

package/src/wrappers/AbstractWrapper.ts

@@ -1,14 +0,0 @@
-import { TranslationTags, TranslationParamsTags, Unwrapped } from '../types';
-
-export interface AbstractWrapper {
-  handleText(node: Element): Promise<void>;
-  handleSubtree(node: Element): Promise<void>;
-  handleAttribute(node: Element): Promise<void>;
-  wrap: (
-    key: string,
-    params?: TranslationParamsTags<any>,
-    defaultValue?: string | undefined,
-    translation?: TranslationTags<any>
-  ) => TranslationTags<any>;
-  unwrap(text: string): Unwrapped;
-}

package/src/wrappers/NodeHandler.ts

@@ -1,143 +0,0 @@
-import { NodeHelper } from '../helpers/NodeHelper';
-import { Properties } from '../Properties';
-import {
-  ElementMeta,
-  ElementWithMeta,
-  KeyAndParamsTags,
-  NodeLock,
-  NodeMeta,
-  NodeWithLock,
-  NodeWithMeta,
-} from '../types';
-import { ElementRegistrar } from '../services/ElementRegistrar';
-import {
-  RESTRICTED_ASCENDANT_ATTRIBUTE,
-  TOLGEE_ATTRIBUTE_NAME,
-} from '../Constants/Global';
-import { AbstractWrapper } from './AbstractWrapper';
-
-export class NodeHandler {
-  constructor(
-    private properties: Properties,
-    private elementRegistrar: ElementRegistrar,
-    private wrapper: AbstractWrapper
-  ) {}
-
-  static initParentElement(element: Element): ElementWithMeta {
-    if (element[TOLGEE_ATTRIBUTE_NAME] === undefined) {
-      element[TOLGEE_ATTRIBUTE_NAME] = {
-        nodes: new Set(),
-      } as ElementMeta;
-      element.setAttribute(TOLGEE_ATTRIBUTE_NAME, '');
-    }
-
-    return element as ElementWithMeta;
-  }
-
-  filterRestricted<T extends Element | Text>(nodes: T[]) {
-    const restrictedElements = this.properties.config.restrictedElements;
-    return nodes.filter((n) => {
-      const e = NodeHelper.closestElement(n);
-      if (!e) {
-        return false;
-      }
-      return (
-        restrictedElements.indexOf(e.tagName.toLowerCase()) === -1 &&
-        e.closest(`[${RESTRICTED_ASCENDANT_ATTRIBUTE}="true"]`) === null
-      );
-    });
-  }
-
-  async handleNodes(nodes: Array<Text | Attr>) {
-    for (const textNode of nodes) {
-      if (textNode[TOLGEE_ATTRIBUTE_NAME] === undefined) {
-        textNode[TOLGEE_ATTRIBUTE_NAME] = {} as NodeLock;
-      }
-      const tolgeeData = textNode[TOLGEE_ATTRIBUTE_NAME] as
-        | NodeMeta
-        | NodeLock
-        | undefined;
-      if (tolgeeData?.locked !== true) {
-        this.lockNode(textNode);
-        const result = await this.wrapper.unwrap(
-          NodeHelper.getNodeText(textNode)
-        );
-        if (result) {
-          const { text, keys } = result;
-          const translatedNode = this.translateChildNode(textNode, text, keys);
-          const parentElement = this.getParentElement(translatedNode);
-          parentElement._tolgee.nodes.add(translatedNode);
-          this.elementRegistrar.register(parentElement);
-        }
-        this.unlockNode(textNode);
-      }
-    }
-  }
-
-  translateChildNode(
-    node: Text | Attr,
-    newValue,
-    keys: KeyAndParamsTags<any>[]
-  ) {
-    node[TOLGEE_ATTRIBUTE_NAME] = {
-      oldTextContent: NodeHelper.getNodeText(node),
-      keys,
-    };
-    NodeHelper.setNodeText(node, newValue);
-    return node as Node as NodeWithMeta;
-  }
-
-  private lockNode(node: Node | Attr): NodeWithLock {
-    if (node[TOLGEE_ATTRIBUTE_NAME] === undefined) {
-      node[TOLGEE_ATTRIBUTE_NAME] = {} as NodeLock;
-    }
-
-    const tolgeeData = node[TOLGEE_ATTRIBUTE_NAME] as NodeMeta | NodeLock;
-    if (tolgeeData?.locked !== true) {
-      tolgeeData.locked = true;
-    }
-
-    return node as NodeWithLock;
-  }
-
-  private unlockNode(node: Node | Attr) {
-    if (node[TOLGEE_ATTRIBUTE_NAME]) {
-      node[TOLGEE_ATTRIBUTE_NAME].locked = false;
-    }
-  }
-
-  private getParentElement(node: Node) {
-    const parent = this.getSuitableParent(node);
-    return NodeHandler.initParentElement(parent);
-  }
-
-  private getSuitableParent(node: Node): Element {
-    const domParent = NodeHelper.getParentElement(node);
-
-    if (domParent === undefined) {
-      // eslint-disable-next-line no-console
-      console.error(node);
-      throw new Error('No suitable parent found for node above.');
-    }
-
-    if (!this.properties.config.passToParent) {
-      return domParent;
-    }
-
-    if (Array.isArray(this.properties.config.passToParent)) {
-      const tagNameEquals = (elementTagName: string) =>
-        domParent.tagName.toLowerCase() === elementTagName.toLowerCase();
-      if (this.properties.config.passToParent.findIndex(tagNameEquals) === -1) {
-        return domParent;
-      }
-    }
-
-    if (typeof this.properties.config.passToParent === 'function') {
-      if (!this.properties.config.passToParent(domParent)) {
-        return domParent;
-      }
-    }
-
-    return this.getSuitableParent(domParent);
-  }
-}

package/src/wrappers/WrappedHandler.ts

@@ -1,28 +0,0 @@
-import { NodeHelper } from '../helpers/NodeHelper';
-import { NodeHandler } from './NodeHandler';
-import { ElementRegistrar } from '../services/ElementRegistrar';
-import { TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE } from '../Constants/Global';
-
-export class WrappedHandler {
-  constructor(
-    private elementRegistrar: ElementRegistrar,
-    private nodeHandler: NodeHandler
-  ) {}
-
-  async handle(node: Node): Promise<void> {
-    const xPath = `./descendant-or-self::*[@${TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE}]`;
-    const nodes = NodeHelper.evaluate(xPath, node);
-    const filtered: Element[] = this.nodeHandler.filterRestricted(
-      nodes as Element[]
-    );
-    filtered.forEach((element) => {
-      const elementWithMeta = NodeHandler.initParentElement(element);
-      elementWithMeta._tolgee.wrappedWithElementOnlyKey = element.getAttribute(
-        TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE
-      );
-      elementWithMeta._tolgee.wrappedWithElementOnlyDefaultHtml =
-        element.innerHTML;
-      this.elementRegistrar.register(elementWithMeta);
-    });
-  }
-}

package/src/wrappers/invisible/AttributeHandler.ts

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

package/src/wrappers/invisible/Coder.ts

@@ -1,65 +0,0 @@
-import {
-  decodeFromText,
-  encodeMessage,
-  removeSecrets,
-  stringToCodePoints,
-} from '../../helpers/secret';
-import {
-  KeyAndParams,
-  TranslationTags,
-  TranslationParamsTags,
-  Unwrapped,
-} from '../../types';
-import { ValueMemory } from './ValueMemory';
-
-export class Coder {
-  private keyMemory = new ValueMemory();
-  private defaultMemory = new ValueMemory();
-
-  unwrap(text: string): Unwrapped {
-    const keysAndParams = [] as KeyAndParams[];
-    const messages = decodeFromText(text);
-
-    messages.forEach((msg) => {
-      const [keyCode, defaultCode] = stringToCodePoints(msg);
-      const key = this.keyMemory.numberToValue(keyCode);
-      const defaultValue =
-        defaultCode !== undefined
-          ? this.defaultMemory.numberToValue(defaultCode)
-          : undefined;
-      keysAndParams.push({
-        key: key,
-        params: undefined,
-        defaultValue,
-      });
-    });
-
-    const result = removeSecrets(text);
-
-    if (keysAndParams.length) {
-      return { text: result, keys: keysAndParams };
-    }
-    return undefined;
-  }
-
-  public wrap(
-    key: string,
-    _params: TranslationParamsTags<any> = {},
-    defaultValue: string | undefined = undefined,
-    translation: string | any[] | undefined = undefined
-  ): TranslationTags<any> {
-    const codes = [this.keyMemory.valueToNumber(key)];
-    if (defaultValue) {
-      codes.push(this.defaultMemory.valueToNumber(defaultValue));
-    }
-
-    const value = translation || '';
-    const invisibleMark = encodeMessage(String.fromCodePoint(...codes));
-
-    return typeof value === 'string'
-      ? value + invisibleMark
-      : Array.isArray(value)
-      ? [...value, invisibleMark]
-      : [value, invisibleMark];
-  }
-}

package/src/wrappers/invisible/ContentHandler.ts

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

package/src/wrappers/invisible/CoreHandler.ts

@@ -1,17 +0,0 @@
-import { ContentHandler } from './ContentHandler';
-import { AttributeHandler } from './AttributeHandler';
-import { WrappedHandler } from '../WrappedHandler';
-
-export class CoreHandler {
-  constructor(
-    private textHandler: ContentHandler,
-    private attributeHandler: AttributeHandler,
-    private wrappedHandler: WrappedHandler
-  ) {}
-
-  public async handleSubtree(target: Element) {
-    await this.attributeHandler.handle(target);
-    await this.textHandler.handle(target);
-    await this.wrappedHandler.handle(target);
-  }
-}

package/src/wrappers/invisible/InvisibleWrapper.ts

@@ -1,59 +0,0 @@
-import { Properties } from '../../Properties';
-import { ElementRegistrar } from '../../services/ElementRegistrar';
-import { TranslationParams } from '../../types';
-import { NodeHandler } from '../NodeHandler';
-import { AttributeHandler } from './AttributeHandler';
-import { Coder } from './Coder';
-import { CoreHandler } from './CoreHandler';
-import { ContentHandler } from './ContentHandler';
-import { WrappedHandler } from '../WrappedHandler';
-import { AbstractWrapper } from '../AbstractWrapper';
-
-export class InvisibleWrapper implements AbstractWrapper {
-  private coder: Coder;
-  private coreHandler: CoreHandler;
-  private attributeHandler: AttributeHandler;
-  private wrappedHandler: WrappedHandler;
-  private textHandler: ContentHandler;
-  private nodeHandler: any;
-  constructor(properties: Properties, elementRegistrar: ElementRegistrar) {
-    this.coder = new Coder();
-    this.nodeHandler = new NodeHandler(properties, elementRegistrar, this);
-    this.textHandler = new ContentHandler(this.nodeHandler);
-    this.attributeHandler = new AttributeHandler(properties, this.nodeHandler);
-    this.wrappedHandler = new WrappedHandler(
-      elementRegistrar,
-      this.nodeHandler
-    );
-    this.coreHandler = new CoreHandler(
-      this.textHandler,
-      this.attributeHandler,
-      this.wrappedHandler
-    );
-  }
-
-  public handleText(node: Element) {
-    return this.textHandler.handle(node);
-  }
-
-  public handleSubtree(node: Element) {
-    return this.coreHandler.handleSubtree(node);
-  }
-
-  public handleAttribute(node: Element) {
-    return this.attributeHandler.handle(node);
-  }
-
-  public wrap(
-    key: string,
-    params: TranslationParams = {},
-    defaultValue: string | undefined = undefined,
-    translation = ''
-  ) {
-    return this.coder.wrap(key, params, defaultValue, translation);
-  }
-
-  public unwrap(text: string) {
-    return this.coder.unwrap(text);
-  }
-}

package/src/wrappers/invisible/ValueMemory.test.ts

@@ -1,25 +0,0 @@
-jest.dontMock('./ValueMemory');
-import { ValueMemory } from './ValueMemory';
-
-describe('Value memory', () => {
-  let valueMemory: ValueMemory;
-
-  beforeEach(() => {
-    valueMemory = new ValueMemory();
-  });
-
-  it('stores key correctly', () => {
-    const num = valueMemory.valueToNumber('abcd');
-    expect(num).toEqual(0);
-    expect(valueMemory.valueToNumber('abcd')).toEqual(0);
-  });
-
-  it('retrieves key correctly', () => {
-    const num = valueMemory.valueToNumber('abcd');
-    expect(valueMemory.numberToValue(num)).toEqual('abcd');
-  });
-
-  it('retrieves missing key correctly', () => {
-    expect(valueMemory.numberToValue(100)).toEqual(undefined);
-  });
-});

package/src/wrappers/invisible/ValueMemory.ts

@@ -1,16 +0,0 @@
-export class ValueMemory {
-  private values: string[] = [];
-
-  public valueToNumber(key: string) {
-    let index = this.values.indexOf(key);
-    if (index === -1) {
-      index = this.values.length;
-      this.values.push(key);
-    }
-    return index;
-  }
-
-  public numberToValue(num: number) {
-    return this.values[num];
-  }
-}

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

@@ -1,118 +0,0 @@
-jest.dontMock('./AttributeHandler');
-jest.dontMock('./TextWrapper');
-jest.dontMock('../NodeHandler');
-jest.dontMock('../../services/EventService');
-jest.dontMock('../../helpers/NodeHelper.ts');
-jest.dontMock('../../services/DependencyService');
-jest.dontMock('../../TolgeeConfig');
-
-import { Properties } from '../../Properties';
-import { AttributeHandler } from './AttributeHandler';
-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 { DependencyService } from '../../services/DependencyService';
-import { Coder } from './Coder';
-
-describe('AttributeHandler', () => {
-  let attributeHandler: AttributeHandler;
-
-  const mockedKeys = [
-    {
-      key: 'dummyKey',
-      params: { dummyParam: 'dummyValue' },
-    },
-  ];
-
-  const mockedTranslateInner = (text) => {
-    return {
-      text: text.replace(/{{(.*?)}}/gs, '$1'),
-      keys: mockedKeys,
-    } as Unwrapped;
-  };
-
-  const gv = (key) => mockedTranslateInner(key).text;
-  const mockedTranslate = jest.fn(mockedTranslateInner);
-  let c: ReturnType<typeof createTestDom>;
-
-  beforeEach(() => {
-    c = createTestDom(document);
-    const dependencyService = new DependencyService();
-    dependencyService.init({});
-    // @ts-ignore
-    attributeHandler = dependencyService.wrapper.attributeHandler;
-    getMockedInstance(Properties).config = {
-      inputPrefix: '{{',
-      inputSuffix: '}}',
-      restrictedElements: [],
-      tagAttributes: {
-        '*': ['aria-label'],
-      },
-      passToParent: ['option'],
-      wrapperMode: 'text',
-    };
-
-    getMockedInstance(Coder).unwrap = (...args) => mockedTranslate(...args);
-  });
-
-  afterEach(async () => {
-    jest.clearAllMocks();
-  });
-
-  describe('in production mode', () => {
-    let xPath: string;
-
-    beforeEach(async () => {
-      await attributeHandler.handle(document.body);
-      xPath = `./div/div/@aria-label[contains(., '${gv(c.ariaLabelKey)}')]`;
-    });
-
-    test('Can be created', () => {
-      expect(attributeHandler).not.toBeUndefined();
-    });
-
-    test('will handle text in aria-label attribute of div', async () => {
-      expect(xPath).toBeFoundIn(document.body);
-    });
-
-    describe("Node's _tolgee property", () => {
-      let node: NodeWithMeta;
-
-      beforeEach(() => {
-        node = NodeHelper.evaluateToSingle(
-          xPath,
-          document.body
-        ) as NodeWithMeta;
-      });
-
-      test('will be defined', () => {
-        expect(node._tolgee).toBeDefined();
-      });
-    });
-
-    describe("Parent element's _tolgee property", () => {
-      let element: ElementWithMeta;
-      let node: NodeWithMeta;
-
-      beforeEach(() => {
-        node = NodeHelper.evaluateToSingle(xPath, document.body);
-        element = (node as any as Attr).ownerElement as any as ElementWithMeta;
-      });
-
-      test('will be defined', () => {
-        expect(element._tolgee).toBeDefined();
-      });
-    });
-  });
-
-  test('will register the node', async () => {
-    await attributeHandler.handle(document.body);
-    const xPath = `./div/div/@aria-label[contains(., '${gv(c.ariaLabelKey)}')]`;
-    const node = NodeHelper.evaluateToSingle(xPath, document.body) as Attr;
-    expect(getMockedInstance(ElementRegistrar).register).toBeCalledWith(
-      node.ownerElement
-    );
-  });
-});

package/src/wrappers/text/AttributeHandler.ts

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