@tilde-nlp/ngx-translate 1.0.0

package/esm2020/lib/modules/tld-text/services/tld-translate-text.service.mjs

@@ -0,0 +1,380 @@
+import { Inject, Injectable } from '@angular/core';
+import { of, Subject, timer } from 'rxjs';
+import { catchError, debounce, distinctUntilChanged, mergeMap, tap } from 'rxjs/operators';
+import { TEXT_API_SERVICE_TOKEN } from '../../../injection-tokens';
+import { Common, ErrorCode } from '../../tld-common/models';
+import { HighlightTreeType } from '../models/highlight-tree-type.model';
+import { TldTranslateTextUtils } from '../utils/tld-translate-text.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../tld-tooltip/services";
+import * as i2 from "../../tld-common/services/scroll/tld-scroll.service";
+import * as i3 from "../../tld-common/services";
+import * as i4 from "@ngx-translate/core";
+export class TldTranslateTextService {
+    constructor(api, systemService, tldScrollService, configService, translate, highlightService, alertsService) {
+        this.api = api;
+        this.systemService = systemService;
+        this.tldScrollService = tldScrollService;
+        this.configService = configService;
+        this.translate = translate;
+        this.highlightService = highlightService;
+        this.alertsService = alertsService;
+        this._sourceChange = new Subject();
+        this._sourceScroll = new Subject();
+        this._translateButtonClick = new Subject();
+        this._onClear = new Subject();
+        this.paragraphs = [];
+        this.sourceParagraphs = [];
+        this.targetParagraphs = [];
+        this.paragraphTranslationsSubject = new Subject();
+        this.debouncer = new Subject();
+        /** How many paragraphs can be translated at the same time. */
+        this.CONCURRENT_UPLOADS = 5;
+        this.DEBOUNCE_TIME = 1000;
+        /** Whether progress indicator should be shown. This value must be set to true only if configured time has passed. */
+        this._shouldShowProgressIndicator = false;
+        this._untranslatedParagraphCount = 0;
+    }
+    get sourceText() {
+        return this._sourceText;
+    }
+    get sourceTextHypothesis() {
+        return this._sourceTextHypothesis;
+    }
+    get sourceChange() { return this._sourceChange.asObservable(); }
+    get sourceScroll() { return this._sourceScroll.asObservable(); }
+    get translateButtonClick() { return this._translateButtonClick.asObservable(); }
+    get hasDictionary() { return this._hasDictionary; }
+    set hasDictionary(val) {
+        this._hasDictionary = val;
+        if (!val) {
+            this._dictionaryEntry = null;
+        }
+    }
+    get dictionaryEntry() { return this._dictionaryEntry; }
+    set dictionaryEntry(val) {
+        this._dictionaryEntry = val;
+        if (this.dictionaryEntry) {
+            this.hasDictionary = true;
+        }
+    }
+    get translatedText() {
+        return this.targetParagraphs.map(line => line.originalText).join("\n");
+    }
+    get firstParagraphTranslated() {
+        return this._firstParagraphTranslated;
+    }
+    get shouldShowProgressIndicator() { return this._shouldShowProgressIndicator; }
+    get untranslatedParagraphCount() { return this._untranslatedParagraphCount; }
+    set untranslatedParagraphCount(value) {
+        this._untranslatedParagraphCount = value;
+        // When translation finished, progress indicator should not be shown.
+        if (value === 0) {
+            this.toggleTextToSpeech();
+            this.hideProgressIndicator();
+        }
+    }
+    get isTranslating() { return this.untranslatedParagraphCount > 0; }
+    // getters from config service.
+    get allowWebsiteTranslation() { return this.configService.textConfig.allowWebsiteTranslation; }
+    ;
+    get autoRedirectToWebTranslate() { return this.configService.textConfig.autoRedirectToWebTranslate; }
+    ;
+    get webWidgetRedirectUrlPrefix() { return this.configService.textConfig.webWidgetRedirectUrlPrefix; }
+    ;
+    get webWidgetRedirectUrlPosfix() { return this.configService.textConfig.webWidgetRedirectUrlPosfix; }
+    ;
+    get useDictionary() { return this.configService.textConfig.useDictionary; }
+    ;
+    get progressIndicatorTimeoutMiliSeconds() { return this.configService.textConfig.progressIndicatorTimeoutMiliSeconds; }
+    // -----------------------------
+    get activeData() {
+        return this.systemService.getActiveSystemObj();
+    }
+    get translateUrlRedirect() {
+        if (this.webWidgetRedirectUrlPrefix === '') {
+            return `${this.webWidgetRedirectUrlPrefix}${this.webWidgetRedirectUrlPosfix}${encodeURIComponent(this.urlToTranslate)}`;
+        }
+        else {
+            return `${this.webWidgetRedirectUrlPrefix}${this.translate.currentLang}${this.webWidgetRedirectUrlPosfix}${this.urlToTranslate}`;
+        }
+    }
+    dictionaryTranslation(text, srcCode, trgCode) {
+        return this.api.dictionaryTranslation(text, srcCode, trgCode);
+    }
+    changeSource(event) {
+        this._sourceText = event.phrase;
+        this._sourceChange.next(event);
+        this.debouncer.next(event);
+    }
+    changeSourceHypothesis(text) {
+        this._sourceTextHypothesis = text;
+    }
+    onSourceScroll(offsetTop) {
+        this._sourceScroll.next(offsetTop);
+    }
+    onTranslateButtonClick() {
+        this._translateButtonClick.next(null);
+        this.retranslate({ buttonClicked: true });
+    }
+    clearSource() {
+        this._onClear.next(null);
+        this.changeSource({ phrase: "" });
+    }
+    onClear() {
+        return this._onClear.asObservable();
+    }
+    updateTranslation(options, systemID, text, translation) {
+        return this.api.updateTranslation(options, systemID, text, translation);
+    }
+    listenOnChanges() {
+        if (this.debouncerSubscription) {
+            return;
+        }
+        this.debouncerSubscription = this.debouncer.pipe(distinctUntilChanged((previous) => {
+            return previous.phrase == this.sourceText;
+        }), debounce(ev => ev.phrase?.length > 0 ? timer(this.DEBOUNCE_TIME) : timer(0)))
+            .subscribe((event) => {
+            this.highlightService.changeSelectedTargetSentence(null);
+            if (!event.disableAutomaticTranslation) {
+                this.retranslate();
+            }
+        });
+    }
+    stopListeningToChanges() {
+        if (!this.debouncerSubscription) {
+            return;
+        }
+        this.debouncerSubscription.unsubscribe();
+        this.debouncerSubscription = null;
+    }
+    // if method gets called because of button click and url entered - go to web translation
+    retranslate(params) {
+        if (!this.sourceText || this.sourceText == "") {
+            this.clearSourceParams();
+            return;
+        }
+        if (params?.buttonClicked || params?.systemChanged) {
+            this.clearSourceParams();
+        }
+        const maxSourceCharacterDictionary = 200;
+        const maxDictionaryWords = 12;
+        const wordsInSource = Common.getWordCount(this.sourceText);
+        this.urlToTranslate = Common.isTextUrl(this.sourceText);
+        if (this.allowWebsiteTranslation && this.urlToTranslate) {
+            this.paragraphs = [];
+            this.sourceParagraphs = [];
+            this.targetParagraphs = [];
+            if (this.autoRedirectToWebTranslate || params?.buttonClicked) {
+                window.open(this.translateUrlRedirect, "_blank");
+            }
+            return;
+        }
+        else {
+            this.urlToTranslate = null;
+        }
+        // TODO. Letonika dictionary?
+        if (this.useDictionary && this.sourceText.length < maxSourceCharacterDictionary && wordsInSource <= maxDictionaryWords) {
+            this.prepareAndTranslateWords();
+            return;
+        }
+        this.translateText(this.sourceText);
+    }
+    /** Stops text translation if it is active. */
+    stopTranslation() {
+        this.untranslatedParagraphCount = 0;
+        if (this.paragraphTranslationSubscription) {
+            this.paragraphTranslationSubscription.unsubscribe();
+        }
+        if (this.dictionarySubscription) {
+            this.dictionarySubscription.unsubscribe();
+        }
+    }
+    recreateParagraphTranslationSubject() {
+        this._firstParagraphTranslated = false;
+        this.paragraphTranslationsSubject = new Subject();
+        const source = this.sourceText;
+        this.untranslatedParagraphCount = 0;
+        this.paragraphTranslationSubscription = this.paragraphTranslationsSubject.asObservable().pipe(mergeMap((untranslatedParagraph) => {
+            this.untranslatedParagraphCount += 1;
+            return this.translateParagraph(untranslatedParagraph).pipe(tap((response) => {
+                // No need to handle response if source text has changed.
+                if (source != this.sourceText) {
+                    return;
+                }
+                this.handleTranslatedParagraph(response);
+                this.updateParagraphs(untranslatedParagraph.ix, response);
+                this.untranslatedParagraphCount -= 1;
+            }), catchError(err => {
+                this.untranslatedParagraphCount -= 1;
+                if (err.status === 500) {
+                    this.alertsService.unhandeledError({ ErrorCode: ErrorCode.TRANSLATION_FAILED });
+                }
+                this.alertsService.unhandeledError(err);
+                // after calling this method, subject is destroyed and unsubscribed, so thrown error wont have any effect.
+                this.stopTranslation();
+                this.alertsService.unhandeledError(err);
+                throw err;
+            }));
+        }, this.CONCURRENT_UPLOADS)).subscribe();
+    }
+    translateParagraph(paragraph) {
+        const params = {
+            paragraphIx: paragraph.ix,
+            text: paragraph.line,
+            system: this.activeData
+        };
+        if (!params.text || params.text.length === 0) {
+            return of({
+                sourceTree: { text: "", paragraphIx: params.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: "" },
+                targetTree: { text: "", paragraphIx: params.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: "" }
+            });
+        }
+        return this.api.translateParagraph(params);
+    }
+    handleTranslatedParagraph(paragraph) {
+        //if auto domain detection is on, system api service sets system id to `${srcLang}-${targetLang}` so we need to validate if that is the case
+        if (paragraph.systemId && this.activeData.id !== paragraph.systemId
+            && this.activeData.id === `${this.activeData.sourceLanguage}-${this.activeData.targetLanguage}`) {
+            this.systemService.changeSystem(paragraph.systemId);
+        }
+        // Needs to scroll to top after first paragraph is translated.
+        if (!this._firstParagraphTranslated) {
+            // if empty paragraph is 'translated' first, no need to do any scrolling. Wait for real text to be translated.
+            if (paragraph.targetTree.text.trim().length > 0) {
+                this._firstParagraphTranslated = true;
+                this.tldScrollService.syncScrollbars(null, 0);
+            }
+        }
+    }
+    updateParagraphs(paragraphIx, response) {
+        let paragraph = {
+            ix: paragraphIx,
+            target: response.targetTree,
+            source: response.sourceTree
+        };
+        this.paragraphs.splice(paragraphIx, 1, paragraph);
+        this.sourceParagraphs.splice(paragraphIx, 1, response.sourceTree);
+        this.targetParagraphs.splice(paragraphIx, 1, response.targetTree);
+        this.paragraphs.sort((a, b) => (a.ix > b.ix) ? 1 : -1);
+    }
+    clearSourceParams() {
+        this._dictionaryEntry = null;
+        this._hasDictionary = false;
+        this.paragraphs = [];
+        this.targetParagraphs = [];
+        this.sourceParagraphs = [];
+        this.urlToTranslate = null;
+        this.textToSpeechTargetSettings = null;
+        this.textToSpeechSourceSettings = null;
+        this.stopTranslation();
+    }
+    prepareAndTranslateWords() {
+        const activeSystemObject = this.activeData;
+        this.dictionarySubscription = this.dictionaryTranslation(this.sourceText.trim(), activeSystemObject.sourceLanguage, activeSystemObject.targetLanguage)
+            .subscribe((response) => {
+            this.dictionarySubscription = null;
+            if (!response || !response[0] || !response[0].translations || response[0].translations.length == 0) {
+                this.translateText(this.sourceText);
+                this.hasDictionary = false;
+                return;
+            }
+            this.dictionaryEntry = response;
+        }, () => {
+            this.translateText(this.sourceText);
+            this.hasDictionary = false;
+        });
+    }
+    translateText(text) {
+        const paragraphs = Common.splitInParagraphs(text);
+        const newParagraphs = [];
+        const newSourceParagraphs = [];
+        const newTargetParagraphs = [];
+        // source text changed. Previously made observables aren't necessary anymore;
+        this.recreateParagraphTranslationSubject();
+        paragraphs.forEach((paragraph, ix) => {
+            // Check if paragraph with same text exists (so you don't have to translate it again).
+            // If it does, you can clone it.
+            const existingParagraphInfo = TldTranslateTextUtils.findExistingParagraph(paragraph, ix, this.paragraphs);
+            const existingParagraph = existingParagraphInfo.existingParagraph;
+            if (existingParagraphInfo.existingParagraph) {
+                if (!existingParagraphInfo.hasSameIx) {
+                    TldTranslateTextUtils.changeRootAndParagraphIx(existingParagraph.source, existingParagraph.source, existingParagraph.ix);
+                    TldTranslateTextUtils.changeRootAndParagraphIx(existingParagraph.target, existingParagraph.target, existingParagraph.ix);
+                }
+                newParagraphs.splice(ix, 0, existingParagraph);
+                newTargetParagraphs.splice(ix, 0, existingParagraph.target);
+                newSourceParagraphs.splice(ix, 0, existingParagraph.source);
+            }
+            else {
+                const newParagraph = TldTranslateTextUtils.createEmptyParagraphInfo(ix);
+                newParagraphs.splice(ix, 0, newParagraph);
+                newSourceParagraphs.splice(ix, 0, newParagraph.source);
+                newTargetParagraphs.splice(ix, 0, newParagraph.target);
+                this.paragraphTranslationsSubject.next({ ix: ix, line: paragraph });
+            }
+        });
+        if (this.isTranslating) {
+            this.setProgressIndicatorTimeout();
+        }
+        this.paragraphs = newParagraphs;
+        this.targetParagraphs = newTargetParagraphs;
+        this.sourceParagraphs = newSourceParagraphs;
+    }
+    /** Creates timeout which enables progress indicator after given miliseconds */
+    setProgressIndicatorTimeout() {
+        if (this.progressIndicatorTimeoutMiliSeconds === null || this.progressIndicatorTimeoutMiliSeconds === undefined) {
+            return;
+        }
+        if (this.configService.textConfig.progressIndicatorVisible) {
+            this.progressIndicatorTimeout = setTimeout(() => {
+                this.showProgressIndicator();
+            }, this.progressIndicatorTimeoutMiliSeconds);
+        }
+    }
+    /** Method for setting necessary properties to make progress indicator visible. */
+    showProgressIndicator() {
+        this._shouldShowProgressIndicator = true;
+    }
+    /** Method for setting necessary properties to make progress indicator hidden. */
+    hideProgressIndicator() {
+        if (this.progressIndicatorTimeout) {
+            clearTimeout(this.progressIndicatorTimeout);
+        }
+        this._shouldShowProgressIndicator = false;
+    }
+    toggleTextToSpeech() {
+        // if nothing translated, tts should not be available
+        if (!this.targetParagraphs.length) {
+            return;
+        }
+        const activeSystem = this.activeData;
+        this.textToSpeechTargetSettings = this.findTextToSpeechSettings(activeSystem.targetLanguage, this.translatedText);
+        this.textToSpeechSourceSettings = this.findTextToSpeechSettings(activeSystem.sourceLanguage, this.sourceText);
+    }
+    findTextToSpeechSettings(languageCode, text) {
+        const settings = this.configService.textToSpeechConfig.languages[languageCode];
+        if (settings) {
+            return {
+                text,
+                url: settings.url,
+                voice: settings.voice,
+                langBpc47: settings.langBpc47,
+                maxCharsInText: this.configService.textToSpeechConfig.maxCharsInText
+            };
+        }
+        return null;
+    }
+}
+TldTranslateTextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextService, deps: [{ token: TEXT_API_SERVICE_TOKEN }, { token: i1.TldSystemService }, { token: i2.TldScrollService }, { token: i3.TldTranslateConfigService }, { token: i4.TranslateService }, { token: i3.TldHighlightService }, { token: i3.TldAlertService }], target: i0.ɵɵFactoryTarget.Injectable });
+TldTranslateTextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TEXT_API_SERVICE_TOKEN]
+                }] }, { type: i1.TldSystemService }, { type: i2.TldScrollService }, { type: i3.TldTranslateConfigService }, { type: i4.TranslateService }, { type: i3.TldHighlightService }, { type: i3.TldAlertService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tld-translate-text.service.js","sourceRoot":"","sources":["../../../../../../../projects/tld-translate/src/lib/modules/tld-text/services/tld-translate-text.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { Observable, of, Subject, Subscription, timer } from 'rxjs';\r\nimport { catchError, debounce, distinctUntilChanged, mergeMap, tap } from 'rxjs/operators';\r\nimport { TextToSpeechSettings } from '../../../components/shared/text-to-speech/models/text-to-speech-settings.model';\r\nimport { TEXT_API_SERVICE_TOKEN } from '../../../injection-tokens';\r\nimport { Common, ErrorCode, ITldTranslateTextApiService, ITranslateParagraphRequestParams } from '../../tld-common/models';\r\nimport { TldAlertService, TldHighlightService, TldTranslateConfigService } from '../../tld-common/services';\r\nimport { TldScrollService } from '../../tld-common/services/scroll/tld-scroll.service';\r\nimport { TldSystemService } from '../../tld-tooltip/services';\r\nimport { IDictionaryEntry, ISourceChangeEvent } from '../models/dictionary.model';\r\nimport { HighlightTreeType } from '../models/highlight-tree-type.model';\r\nimport { IHighlightTree } from '../models/highlight-tree.model';\r\nimport { IParagraphInfo } from '../models/highlight.model';\r\nimport { IRetranslateParams } from '../models/retranslate-params.model';\r\nimport { ITranslateParagraphResponse } from '../models/translate-paragraph-response.model';\r\nimport { IUntranslatedParagraph } from '../models/untranslated-paragraph.model';\r\nimport { TldTranslateTextUtils } from '../utils/tld-translate-text.utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TldTranslateTextService {\r\n\r\n  private _sourceText: string;\r\n  get sourceText() {\r\n    return this._sourceText;\r\n  }\r\n\r\n  private _sourceTextHypothesis: string;\r\n  get sourceTextHypothesis() {\r\n    return this._sourceTextHypothesis;\r\n  }\r\n\r\n  private _sourceChange: Subject<ISourceChangeEvent> = new Subject();\r\n  get sourceChange() { return this._sourceChange.asObservable(); }\r\n\r\n  private _sourceScroll: Subject<number> = new Subject();\r\n  get sourceScroll() { return this._sourceScroll.asObservable(); }\r\n\r\n  private _translateButtonClick: Subject<any> = new Subject();\r\n  get translateButtonClick() { return this._translateButtonClick.asObservable(); }\r\n\r\n  private _hasDictionary: boolean;\r\n  get hasDictionary() { return this._hasDictionary; }\r\n  set hasDictionary(val) {\r\n    this._hasDictionary = val;\r\n    if (!val) {\r\n      this._dictionaryEntry = null;\r\n    }\r\n  }\r\n\r\n  private _dictionaryEntry: IDictionaryEntry[];\r\n  get dictionaryEntry() { return this._dictionaryEntry; }\r\n  set dictionaryEntry(val) {\r\n    this._dictionaryEntry = val;\r\n    if (this.dictionaryEntry) {\r\n      this.hasDictionary = true;\r\n    }\r\n  }\r\n  get translatedText(): string {\r\n    return this.targetParagraphs.map(line => line.originalText).join(\"\\n\")\r\n  }\r\n\r\n  private readonly _onClear = new Subject<any>();\r\n\r\n  urlToTranslate: string;\r\n  paragraphs: IParagraphInfo[] = [];\r\n  sourceParagraphs: IHighlightTree[] = [];\r\n  targetParagraphs: IHighlightTree[] = [];\r\n\r\n  // Set this object with necessary values to display TTS component\r\n  textToSpeechSourceSettings: TextToSpeechSettings;\r\n  textToSpeechTargetSettings: TextToSpeechSettings;\r\n\r\n  private _firstParagraphTranslated: boolean;\r\n  get firstParagraphTranslated() {\r\n    return this._firstParagraphTranslated;\r\n  }\r\n\r\n  private dictionarySubscription: Subscription;\r\n  private paragraphTranslationsSubject = new Subject<IUntranslatedParagraph>();\r\n  private paragraphTranslationSubscription: Subscription;\r\n  private readonly debouncer: Subject<ISourceChangeEvent> = new Subject<ISourceChangeEvent>();\r\n  private debouncerSubscription: Subscription;\r\n  /** How many paragraphs can be translated at the same time. */\r\n  private readonly CONCURRENT_UPLOADS = 5;\r\n  private readonly DEBOUNCE_TIME = 1000;\r\n\r\n  /** Whether progress indicator should be shown. This value must be set to true only if configured time has passed. */\r\n  private _shouldShowProgressIndicator = false;\r\n  get shouldShowProgressIndicator() { return this._shouldShowProgressIndicator; }\r\n  //NodeJS.Timeout\r\n  private progressIndicatorTimeout: any;\r\n\r\n  private _untranslatedParagraphCount = 0;\r\n  get untranslatedParagraphCount() { return this._untranslatedParagraphCount; }\r\n  set untranslatedParagraphCount(value: number) {\r\n    this._untranslatedParagraphCount = value;\r\n    // When translation finished, progress indicator should not be shown.\r\n    if (value === 0) {\r\n      this.toggleTextToSpeech();\r\n      this.hideProgressIndicator();\r\n    }\r\n  }\r\n\r\n  get isTranslating() { return this.untranslatedParagraphCount > 0; }\r\n\r\n  // getters from config service.\r\n  get allowWebsiteTranslation(): boolean { return this.configService.textConfig.allowWebsiteTranslation; };\r\n  get autoRedirectToWebTranslate(): boolean { return this.configService.textConfig.autoRedirectToWebTranslate; };\r\n  get webWidgetRedirectUrlPrefix(): string { return this.configService.textConfig.webWidgetRedirectUrlPrefix; };\r\n  get webWidgetRedirectUrlPosfix(): string { return this.configService.textConfig.webWidgetRedirectUrlPosfix; };\r\n  get useDictionary(): boolean { return this.configService.textConfig.useDictionary; };\r\n  get progressIndicatorTimeoutMiliSeconds(): number { return this.configService.textConfig.progressIndicatorTimeoutMiliSeconds; }\r\n  // -----------------------------\r\n\r\n  get activeData() {\r\n    return this.systemService.getActiveSystemObj();\r\n  }\r\n\r\n  get translateUrlRedirect() {\r\n    if (this.webWidgetRedirectUrlPrefix === '') {\r\n      return `${this.webWidgetRedirectUrlPrefix}${this.webWidgetRedirectUrlPosfix}${encodeURIComponent(this.urlToTranslate)}`;\r\n    } else {\r\n      return `${this.webWidgetRedirectUrlPrefix}${this.translate.currentLang}${this.webWidgetRedirectUrlPosfix}${this.urlToTranslate}`;\r\n    }\r\n  }\r\n\r\n  /** If dictattion is active. Based on this, extensions are hidden. */\r\n  isDictating: boolean;\r\n\r\n  constructor(@Inject(TEXT_API_SERVICE_TOKEN) private readonly api: ITldTranslateTextApiService,\r\n    private readonly systemService: TldSystemService,\r\n    private readonly tldScrollService: TldScrollService,\r\n    private readonly configService: TldTranslateConfigService,\r\n    private readonly translate: TranslateService,\r\n    private readonly highlightService: TldHighlightService,\r\n    private readonly alertsService: TldAlertService) { }\r\n\r\n  dictionaryTranslation(text: string, srcCode: string, trgCode: string) {\r\n    return this.api.dictionaryTranslation(text, srcCode, trgCode);\r\n  }\r\n\r\n  changeSource(event: ISourceChangeEvent) {\r\n    this._sourceText = event.phrase;\r\n    this._sourceChange.next(event);\r\n    this.debouncer.next(event);\r\n  }\r\n\r\n  changeSourceHypothesis(text: string) {\r\n    this._sourceTextHypothesis = text;\r\n  }\r\n\r\n  onSourceScroll(offsetTop: number) {\r\n    this._sourceScroll.next(offsetTop);\r\n  }\r\n\r\n  onTranslateButtonClick() {\r\n    this._translateButtonClick.next(null)\r\n    this.retranslate({ buttonClicked: true });\r\n  }\r\n\r\n  clearSource() {\r\n    this._onClear.next(null)\r\n    this.changeSource({ phrase: \"\" })\r\n  }\r\n\r\n  onClear(): Observable<any> {\r\n    return this._onClear.asObservable();\r\n  }\r\n\r\n  updateTranslation(options: string, systemID: string, text: string, translation: string) {\r\n    return this.api.updateTranslation(options, systemID, text, translation);\r\n  }\r\n\r\n  listenOnChanges() {\r\n    if (this.debouncerSubscription) {\r\n      return;\r\n    }\r\n\r\n    this.debouncerSubscription = this.debouncer.pipe(\r\n      distinctUntilChanged((previous) => {\r\n        return previous.phrase == this.sourceText;\r\n      }),\r\n      debounce(ev => ev.phrase?.length > 0 ? timer(this.DEBOUNCE_TIME) : timer(0))\r\n    )\r\n      .subscribe((event) => {\r\n        this.highlightService.changeSelectedTargetSentence(null);\r\n\r\n        if (!event.disableAutomaticTranslation) {\r\n          this.retranslate();\r\n        }\r\n      });\r\n  }\r\n\r\n  stopListeningToChanges() {\r\n    if (!this.debouncerSubscription) {\r\n      return;\r\n    }\r\n    this.debouncerSubscription.unsubscribe();\r\n    this.debouncerSubscription = null;\r\n  }\r\n\r\n  // if method gets called because of button click and url entered - go to web translation\r\n  retranslate(params?: IRetranslateParams) {\r\n    if (!this.sourceText || this.sourceText == \"\") {\r\n      this.clearSourceParams();\r\n      return;\r\n    }\r\n\r\n    if (params?.buttonClicked || params?.systemChanged) {\r\n      this.clearSourceParams();\r\n    }\r\n\r\n    const maxSourceCharacterDictionary = 200;\r\n    const maxDictionaryWords = 12;\r\n\r\n    const wordsInSource = Common.getWordCount(this.sourceText);\r\n    this.urlToTranslate = Common.isTextUrl(this.sourceText);\r\n    if (this.allowWebsiteTranslation && this.urlToTranslate) {\r\n      this.paragraphs = [];\r\n      this.sourceParagraphs = [];\r\n      this.targetParagraphs = [];\r\n\r\n      if (this.autoRedirectToWebTranslate || params?.buttonClicked) {\r\n        window.open(this.translateUrlRedirect, \"_blank\");\r\n      }\r\n      return;\r\n    }\r\n    else {\r\n      this.urlToTranslate = null;\r\n    }\r\n    // TODO. Letonika dictionary?\r\n    if (this.useDictionary && this.sourceText.length < maxSourceCharacterDictionary && wordsInSource <= maxDictionaryWords) {\r\n      this.prepareAndTranslateWords();\r\n      return;\r\n    }\r\n    this.translateText(this.sourceText);\r\n  }\r\n\r\n  /** Stops text translation if it is active. */\r\n  stopTranslation() {\r\n    this.untranslatedParagraphCount = 0;\r\n    if (this.paragraphTranslationSubscription) {\r\n      this.paragraphTranslationSubscription.unsubscribe();\r\n    }\r\n\r\n    if (this.dictionarySubscription) {\r\n      this.dictionarySubscription.unsubscribe();\r\n    }\r\n  }\r\n\r\n  private recreateParagraphTranslationSubject() {\r\n    this._firstParagraphTranslated = false;\r\n    this.paragraphTranslationsSubject = new Subject<IUntranslatedParagraph>();\r\n\r\n    const source = this.sourceText;\r\n    this.untranslatedParagraphCount = 0;\r\n    this.paragraphTranslationSubscription = this.paragraphTranslationsSubject.asObservable().pipe(\r\n      mergeMap((untranslatedParagraph) => {\r\n        this.untranslatedParagraphCount += 1;\r\n        return this.translateParagraph(untranslatedParagraph).pipe(\r\n          tap((response: ITranslateParagraphResponse) => {\r\n            // No need to handle response if source text has changed.\r\n            if (source != this.sourceText) {\r\n              return;\r\n            }\r\n            this.handleTranslatedParagraph(response);\r\n            this.updateParagraphs(untranslatedParagraph.ix, response);\r\n            this.untranslatedParagraphCount -= 1;\r\n          }),\r\n          catchError(err => {\r\n            this.untranslatedParagraphCount -= 1;\r\n            if (err.status === 500) {\r\n              this.alertsService.unhandeledError({ ErrorCode: ErrorCode.TRANSLATION_FAILED });\r\n            }\r\n            this.alertsService.unhandeledError(err);\r\n\r\n            // after calling this method, subject is destroyed and unsubscribed, so thrown error wont have any effect.\r\n            this.stopTranslation();\r\n            this.alertsService.unhandeledError(err);\r\n            throw err;\r\n          }))\r\n      }, this.CONCURRENT_UPLOADS),\r\n    ).subscribe();\r\n  }\r\n\r\n  private translateParagraph(paragraph: IUntranslatedParagraph): Observable<ITranslateParagraphResponse> {\r\n    const params: ITranslateParagraphRequestParams = {\r\n      paragraphIx: paragraph.ix,\r\n      text: paragraph.line,\r\n      system: this.activeData\r\n    };\r\n    if (!params.text || params.text.length === 0) {\r\n      return of({\r\n        sourceTree: { text: \"\", paragraphIx: params.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: \"\" },\r\n        targetTree: { text: \"\", paragraphIx: params.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: \"\" }\r\n      });\r\n    }\r\n\r\n    return this.api.translateParagraph(params);\r\n  }\r\n\r\n  private handleTranslatedParagraph(paragraph: ITranslateParagraphResponse) {\r\n    //if auto domain detection is on, system api service sets system id to `${srcLang}-${targetLang}` so we need to validate if that is the case\r\n    if (paragraph.systemId && this.activeData.id !== paragraph.systemId\r\n      && this.activeData.id === `${this.activeData.sourceLanguage}-${this.activeData.targetLanguage}`) {\r\n      this.systemService.changeSystem(paragraph.systemId);\r\n    }\r\n\r\n    // Needs to scroll to top after first paragraph is translated.\r\n    if (!this._firstParagraphTranslated) {\r\n      // if empty paragraph is 'translated' first, no need to do any scrolling. Wait for real text to be translated.\r\n      if (paragraph.targetTree.text.trim().length > 0) {\r\n        this._firstParagraphTranslated = true;\r\n        this.tldScrollService.syncScrollbars(null, 0);\r\n      }\r\n    }\r\n  }\r\n\r\n  private updateParagraphs(paragraphIx: number, response: ITranslateParagraphResponse) {\r\n    let paragraph: IParagraphInfo = {\r\n      ix: paragraphIx,\r\n      target: response.targetTree,\r\n      source: response.sourceTree\r\n    };\r\n\r\n    this.paragraphs.splice(paragraphIx, 1, paragraph);\r\n    this.sourceParagraphs.splice(paragraphIx, 1, response.sourceTree);\r\n    this.targetParagraphs.splice(paragraphIx, 1, response.targetTree);\r\n\r\n    this.paragraphs.sort((a, b) => (a.ix > b.ix) ? 1 : -1);\r\n  }\r\n\r\n  private clearSourceParams() {\r\n    this._dictionaryEntry = null;\r\n    this._hasDictionary = false;\r\n    this.paragraphs = [];\r\n    this.targetParagraphs = [];\r\n    this.sourceParagraphs = [];\r\n    this.urlToTranslate = null;\r\n    this.textToSpeechTargetSettings = null;\r\n    this.textToSpeechSourceSettings = null;\r\n    this.stopTranslation();\r\n  }\r\n\r\n\r\n  private prepareAndTranslateWords() {\r\n    const activeSystemObject = this.activeData;\r\n    this.dictionarySubscription = this.dictionaryTranslation(this.sourceText.trim(),\r\n      activeSystemObject.sourceLanguage, activeSystemObject.targetLanguage)\r\n      .subscribe((response: IDictionaryEntry[]) => {\r\n        this.dictionarySubscription = null;\r\n        if (!response || !response[0] || !response[0].translations || response[0].translations.length == 0) {\r\n          this.translateText(this.sourceText);\r\n          this.hasDictionary = false;\r\n          return;\r\n        }\r\n        this.dictionaryEntry = response;\r\n      }, () => {\r\n        this.translateText(this.sourceText);\r\n        this.hasDictionary = false;\r\n      });\r\n  }\r\n\r\n  private translateText(text: string) {\r\n    const paragraphs = Common.splitInParagraphs(text);\r\n    const newParagraphs: IParagraphInfo[] = [];\r\n    const newSourceParagraphs: IHighlightTree[] = [];\r\n    const newTargetParagraphs: IHighlightTree[] = [];\r\n\r\n    // source text changed. Previously made observables aren't necessary anymore;\r\n    this.recreateParagraphTranslationSubject();\r\n\r\n    paragraphs.forEach((paragraph, ix) => {\r\n      // Check if paragraph with same text exists (so you don't have to translate it again).\r\n      // If it does, you can clone it.\r\n      const existingParagraphInfo = TldTranslateTextUtils.findExistingParagraph(paragraph, ix, this.paragraphs);\r\n      const existingParagraph = existingParagraphInfo.existingParagraph;\r\n      if (existingParagraphInfo.existingParagraph) {\r\n        if (!existingParagraphInfo.hasSameIx) {\r\n          TldTranslateTextUtils.changeRootAndParagraphIx(existingParagraph.source, existingParagraph.source, existingParagraph.ix);\r\n          TldTranslateTextUtils.changeRootAndParagraphIx(existingParagraph.target, existingParagraph.target, existingParagraph.ix);\r\n        }\r\n        newParagraphs.splice(ix, 0, existingParagraph);\r\n        newTargetParagraphs.splice(ix, 0, existingParagraph.target);\r\n        newSourceParagraphs.splice(ix, 0, existingParagraph.source);\r\n      }\r\n      else {\r\n        const newParagraph = TldTranslateTextUtils.createEmptyParagraphInfo(ix);\r\n\r\n        newParagraphs.splice(ix, 0, newParagraph);\r\n        newSourceParagraphs.splice(ix, 0, newParagraph.source);\r\n        newTargetParagraphs.splice(ix, 0, newParagraph.target);\r\n        this.paragraphTranslationsSubject.next({ ix: ix, line: paragraph });\r\n      }\r\n    });\r\n\r\n    if (this.isTranslating) {\r\n      this.setProgressIndicatorTimeout();\r\n    }\r\n\r\n    this.paragraphs = newParagraphs;\r\n    this.targetParagraphs = newTargetParagraphs;\r\n    this.sourceParagraphs = newSourceParagraphs;\r\n  }\r\n\r\n  /** Creates timeout which enables progress indicator after given miliseconds */\r\n  private setProgressIndicatorTimeout() {\r\n    if (this.progressIndicatorTimeoutMiliSeconds === null || this.progressIndicatorTimeoutMiliSeconds === undefined) {\r\n      return;\r\n    }\r\n\r\n    if (this.configService.textConfig.progressIndicatorVisible) {\r\n      this.progressIndicatorTimeout = setTimeout(() => {\r\n        this.showProgressIndicator();\r\n      }, this.progressIndicatorTimeoutMiliSeconds);\r\n    }\r\n  }\r\n\r\n  /** Method for setting necessary properties to make progress indicator visible. */\r\n  private showProgressIndicator() {\r\n    this._shouldShowProgressIndicator = true;\r\n  }\r\n\r\n  /** Method for setting necessary properties to make progress indicator hidden. */\r\n  hideProgressIndicator() {\r\n    if (this.progressIndicatorTimeout) {\r\n      clearTimeout(this.progressIndicatorTimeout);\r\n    }\r\n    this._shouldShowProgressIndicator = false;\r\n  }\r\n\r\n  private toggleTextToSpeech() {\r\n    // if nothing translated, tts should not be available\r\n    if (!this.targetParagraphs.length) {\r\n      return;\r\n    }\r\n\r\n    const activeSystem = this.activeData;\r\n    this.textToSpeechTargetSettings = this.findTextToSpeechSettings(activeSystem.targetLanguage, this.translatedText);\r\n    this.textToSpeechSourceSettings = this.findTextToSpeechSettings(activeSystem.sourceLanguage, this.sourceText);\r\n  }\r\n\r\n  private findTextToSpeechSettings(languageCode: string, text: string): TextToSpeechSettings {\r\n    const settings = this.configService.textToSpeechConfig.languages[languageCode];\r\n    if (settings) {\r\n      return {\r\n        text,\r\n        url: settings.url,\r\n        voice: settings.voice,\r\n        langBpc47: settings.langBpc47,\r\n        maxCharsInText: this.configService.textToSpeechConfig.maxCharsInText\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n}\r\n"]}

package/esm2020/lib/modules/tld-text/tld-text.module.mjs

@@ -0,0 +1,95 @@
+import { ClipboardModule } from '@angular/cdk/clipboard';
+import { LayoutModule } from '@angular/cdk/layout';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { TranslateModule } from '@ngx-translate/core';
+import { CloseButtonModule } from '@tilde-nlp/ngx-common';
+import { ExtensionDialogModule } from '../../components/shared/extension-dialog';
+import { TextToSpeechModule } from '../../components/shared/text-to-speech/text-to-speech.module';
+import { VendorDisclaimerModule } from '../../components/shared/vendor-disclaimer/vendor-disclaimer.module';
+import { MaterialModule } from '../material.module';
+import { TldAudioModule } from '../tld-audio';
+import { TldCommonModule } from '../tld-common/tld-common.module';
+import { HighlightTreeComponent } from './components/highlight-tree/highlight-tree.component';
+import { ProgressIndicatorComponent } from './components/progress-indicator/progress-indicator.component';
+import { TextareaWithBackgroundComponent } from './components/textarea-with-background/textarea-with-background.component';
+import { TldDictionaryComponent } from './components/tld-dictionary/tld-dictionary.component';
+import { TldTranslateSourceComponent } from './components/tld-translate-source/tld-translate-source.component';
+import { TldTranslateSuggestDialogComponent } from './components/tld-translate-suggest/dialog/tld-translate-suggest-dialog.component';
+import { TldTranslateSuggestComponent } from './components/tld-translate-suggest/tld-translate-suggest.component';
+import { TldTranslateTextComponent } from './components/tld-translate-text/tld-translate-text.component';
+import * as i0 from "@angular/core";
+export class TldTextModule {
+}
+TldTextModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTextModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TldTextModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: TldTextModule, declarations: [TldTranslateSourceComponent,
+        TldTranslateSuggestComponent,
+        TldTranslateSuggestDialogComponent,
+        TldTranslateTextComponent,
+        TldDictionaryComponent,
+        TextareaWithBackgroundComponent,
+        HighlightTreeComponent,
+        ProgressIndicatorComponent], imports: [CommonModule,
+        TranslateModule,
+        MaterialModule,
+        FormsModule,
+        TldCommonModule,
+        ClipboardModule,
+        TldAudioModule,
+        CloseButtonModule,
+        ExtensionDialogModule,
+        LayoutModule,
+        MatProgressBarModule,
+        VendorDisclaimerModule,
+        TextToSpeechModule], exports: [TldTranslateSourceComponent,
+        TldTranslateSuggestComponent,
+        TldTranslateTextComponent] });
+TldTextModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTextModule, imports: [CommonModule,
+        TranslateModule,
+        MaterialModule,
+        FormsModule,
+        TldCommonModule,
+        ClipboardModule,
+        TldAudioModule,
+        CloseButtonModule,
+        ExtensionDialogModule,
+        LayoutModule,
+        MatProgressBarModule,
+        VendorDisclaimerModule,
+        TextToSpeechModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTextModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [TldTranslateSourceComponent,
+                        TldTranslateSuggestComponent,
+                        TldTranslateSuggestDialogComponent,
+                        TldTranslateTextComponent,
+                        TldDictionaryComponent,
+                        TextareaWithBackgroundComponent,
+                        HighlightTreeComponent,
+                        ProgressIndicatorComponent],
+                    imports: [
+                        CommonModule,
+                        TranslateModule,
+                        MaterialModule,
+                        FormsModule,
+                        TldCommonModule,
+                        ClipboardModule,
+                        TldAudioModule,
+                        CloseButtonModule,
+                        ExtensionDialogModule,
+                        LayoutModule,
+                        MatProgressBarModule,
+                        VendorDisclaimerModule,
+                        TextToSpeechModule
+                    ],
+                    exports: [
+                        TldTranslateSourceComponent,
+                        TldTranslateSuggestComponent,
+                        TldTranslateTextComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/tld-text/utils/index.mjs

@@ -0,0 +1,2 @@
+export * from './models';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGV4dC91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJzsiXX0=

package/esm2020/lib/modules/tld-text/utils/models/existing-paragraph-info.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhpc3RpbmctcGFyYWdyYXBoLWluZm8ubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGV4dC91dGlscy9tb2RlbHMvZXhpc3RpbmctcGFyYWdyYXBoLWluZm8ubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElQYXJhZ3JhcGhJbmZvIH0gZnJvbSBcIi4uLy4uL21vZGVscy9oaWdobGlnaHQubW9kZWxcIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSUV4aXN0aW5nUGFyYWdyYXBoSW5mb3tcclxuICAgIGhhc1NhbWVJeDogYm9vbGVhbjtcclxuICAgIGV4aXN0aW5nUGFyYWdyYXBoOiBJUGFyYWdyYXBoSW5mbztcclxufSJdfQ==

package/esm2020/lib/modules/tld-text/utils/models/index.mjs

@@ -0,0 +1,2 @@
+export * from './existing-paragraph-info.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGV4dC91dGlscy9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXhpc3RpbmctcGFyYWdyYXBoLWluZm8ubW9kZWwnOyJdfQ==