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

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

@@ -1,106 +0,0 @@
-jest.dontMock('./CoreHandler');
-jest.dontMock('./TextWrapper');
-jest.dontMock('../../helpers/NodeHelper');
-jest.dontMock('../../services/EventEmitter');
-jest.dontMock('../../services/DependencyService');
-
-import { CoreHandler } from './CoreHandler';
-import { getMockedInstance } from '@testFixtures/mocked';
-import { ContentHandler } from './ContentHandler';
-import { AttributeHandler } from './AttributeHandler';
-import { EventService } from '../../services/EventService';
-import { EventEmitterImpl } from '../../services/EventEmitter';
-import { mocked } from 'jest-mock';
-import { TranslationData } from '../../types/DTOs';
-import { Properties } from '../../Properties';
-import { ElementMeta, NodeMeta, NodeWithMeta, Unwrapped } from '../../types';
-import { DependencyService } from '../../services/DependencyService';
-import { Coder } from './Coder';
-
-describe('CoreHandler', () => {
-  const mockedTranslationChanged = new EventEmitterImpl<TranslationData>();
-  const mockedLanguageChanged = new EventEmitterImpl<string>();
-  const mockedUnwrap: Unwrapped = {
-    keys: [{} as any],
-    text: 'This is refreshed',
-  };
-
-  mocked(EventService).mockImplementation(() => {
-    return {
-      TRANSLATION_CHANGED: mockedTranslationChanged,
-      LANGUAGE_CHANGED: mockedLanguageChanged,
-      LANGUAGE_LOADED: null,
-      ELEMENT_REGISTERED: null,
-    } as EventService;
-  });
-
-  mocked(Coder).mockImplementation(() => {
-    return {
-      unwrap: jest.fn(() => mockedUnwrap),
-    } as any as Coder;
-  });
-
-  let coreHandler: CoreHandler;
-
-  beforeEach(async () => {
-    const dependencyStore = new DependencyService();
-    dependencyStore.init({});
-
-    // @ts-ignore
-    coreHandler = dependencyStore.wrapper.coreHandler;
-    getMockedInstance(Properties).config.targetElement = document.body;
-  });
-
-  afterEach(async () => {
-    jest.clearAllMocks();
-  });
-
-  test('Can be created', () => {
-    expect(coreHandler).not.toBeUndefined();
-  });
-
-  describe('handleSubtree function', () => {
-    beforeEach(async () => {
-      await coreHandler.handleSubtree(document.body);
-    });
-
-    test('will call basic text handler', async () => {
-      expect(getMockedInstance(ContentHandler).handle).toBeCalledWith(
-        document.body
-      );
-      expect(getMockedInstance(ContentHandler).handle).toBeCalledTimes(1);
-    });
-
-    test('will call attribute handler', async () => {
-      expect(getMockedInstance(AttributeHandler).handle).toBeCalledWith(
-        document.body
-      );
-      expect(getMockedInstance(AttributeHandler).handle).toBeCalledTimes(1);
-    });
-  });
-
-  describe('refresh', () => {
-    const pgDiv = document.createElement('div');
-    pgDiv.setAttribute('_tolgee', '');
-    const textNode = document.createTextNode('Translated text');
-    textNode['_tolgee'] = {
-      oldTextContent: 'some_translation_key',
-    } as NodeMeta;
-    pgDiv['_tolgee'] = {
-      nodes: new Set([textNode as any as NodeWithMeta]),
-    } as ElementMeta;
-    pgDiv.append(textNode);
-
-    beforeEach(async () => {
-      document.body = document.createElement('body');
-      document.body.append(pgDiv);
-
-      await mockedLanguageChanged.emit('aaa');
-      await mockedTranslationChanged.emit(null);
-    });
-
-    test('will refresh the text', async () => {
-      expect(textNode.textContent).toEqual(mockedUnwrap.text);
-    });
-  });
-});

package/src/wrappers/text/CoreHandler.ts

@@ -1,45 +0,0 @@
-import { NodeHelper } from '../../helpers/NodeHelper';
-import { ContentHandler } from './ContentHandler';
-import { EventService } from '../../services/EventService';
-import { Properties } from '../../Properties';
-import { AttributeHandler } from './AttributeHandler';
-import { ElementWithMeta } from '../../types';
-import { WrappedHandler } from '../WrappedHandler';
-import { Coder } from './Coder';
-
-export class CoreHandler {
-  constructor(
-    private textHandler: ContentHandler,
-    private eventService: EventService,
-    private properties: Properties,
-    private attributeHandler: AttributeHandler,
-    private coder: Coder,
-    private wrappedHandler: WrappedHandler
-  ) {
-    if (typeof window !== 'undefined') {
-      eventService.LANGUAGE_CHANGED.subscribe(this.refresh.bind(this));
-      eventService.TRANSLATION_CHANGED.subscribe(this.refresh.bind(this));
-    }
-  }
-
-  public async handleSubtree(target: Element) {
-    await this.attributeHandler.handle(target);
-    await this.textHandler.handle(target);
-    await this.wrappedHandler.handle(target);
-  }
-
-  private async refresh() {
-    const nodes: ElementWithMeta[] = NodeHelper.evaluate(
-      `//*[@_tolgee]`,
-      this.properties.config.targetElement
-    );
-    for (const node of nodes) {
-      for (const textNode of node._tolgee.nodes) {
-        const result = await this.coder.unwrap(textNode._tolgee.oldTextContent);
-        if (result) {
-          NodeHelper.setNodeText(textNode, result.text);
-        }
-      }
-    }
-  }
-}

package/src/wrappers/text/TextWrapper.ts

@@ -1,69 +0,0 @@
-import { Properties } from '../../Properties';
-import { ElementRegistrar } from '../../services/ElementRegistrar';
-import { EventService } from '../../services/EventService';
-import { TextService } from '../../services/TextService';
-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 TextWrapper implements AbstractWrapper {
-  private coder: Coder;
-  private coreHandler: CoreHandler;
-  private attributeHandler: AttributeHandler;
-  private wrappedHandler: WrappedHandler;
-  private textHandler: ContentHandler;
-  private nodeHandler: any;
-  constructor(
-    eventService: EventService,
-    properties: Properties,
-    textService: TextService,
-    elementRegistrar: ElementRegistrar
-  ) {
-    this.coder = new Coder(properties, textService);
-    this.nodeHandler = new NodeHandler(properties, elementRegistrar, this);
-    this.textHandler = new ContentHandler(properties, this.nodeHandler);
-    this.attributeHandler = new AttributeHandler(properties, this.nodeHandler);
-    this.wrappedHandler = new WrappedHandler(
-      elementRegistrar,
-      this.nodeHandler
-    );
-    this.coreHandler = new CoreHandler(
-      this.textHandler,
-      eventService,
-      properties,
-      this.attributeHandler,
-      this.coder,
-      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: string
-  ) {
-    return this.coder.wrap(key, params, defaultValue);
-  }
-
-  public unwrap(text: string) {
-    return this.coder.unwrap(text);
-  }
-}