@tilde-nlp/ngx-translate 1.0.0

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

@@ -0,0 +1,187 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { Common } from '../../../tld-common/models';
+import { HighlightParams } from '../../models/highlight-params.model';
+import { HighlightTreeType } from '../../models/highlight-tree-type.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../tld-term/services";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../../../tld-common/services";
+export class TldTranslateTextApiService {
+    constructor(collectionService, http, config, alerts) {
+        this.collectionService = collectionService;
+        this.http = http;
+        this.config = config;
+        this.alerts = alerts;
+    }
+    updateTranslation(options, systemID, text, translation) {
+        const url = this.config.textConfig.updateTranslationUrl;
+        const headers = Common.getAuthHeaders(this.config);
+        const params = {
+            appID: this.config.coreConfig.appId,
+            options,
+            systemID,
+            text,
+            translation
+        };
+        return this.http.post(url, params, { headers });
+    }
+    dictionaryTranslation(text, srcCode, trgCode) {
+        const authHeaders = Common.getAuthHeaders(this.config);
+        // TODO. Create type for params.
+        const params = {
+            word: text,
+            sourceLanguage: srcCode,
+            targetLanguage: trgCode
+        };
+        return this.http.get(this.config.textConfig.dictionaryUrl, { headers: authHeaders, params: params });
+    }
+    translateParagraph(requestParams) {
+        const headers = Common.getAuthHeaders(this.config);
+        // TODO. Create type for params.
+        const params = {
+            appID: this.config.coreConfig.appId,
+            options: "widget=text,alignment,markSentences",
+            systemID: requestParams.system.id,
+            text: requestParams.text,
+        };
+        const selectedCollectionId = this.collectionService.selectedIdForTranslation();
+        if (selectedCollectionId) {
+            params.options += `,termCorpusId=${selectedCollectionId}`;
+        }
+        return this.http.get(this.config?.textConfig?.translationUrl, { headers: headers, params: params }).pipe(map((response) => {
+            if (response.ErrorMessage) {
+                this.alerts.unhandeledError(response.ErrorMessage);
+                throw response.ErrorMessage;
+            }
+            const converted = this.convertParagraphResponse(requestParams, response);
+            return converted;
+        }));
+    }
+    convertParagraphResponse(request, response) {
+        if (this.config.textConfig.highlight) {
+            return this.createHighlightTrees(request.text, response, request.paragraphIx);
+        }
+        else {
+            return {
+                sourceTree: { text: request.text, paragraphIx: request.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: request.text },
+                targetTree: { text: response.translation, paragraphIx: request.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: response.translation }
+            };
+        }
+    }
+    createHighlightTrees(sourceText, response, paragraphIx) {
+        const targetTree = this.getSentence(response.translation, response.translationSentenceRanges, response.targetWordRanges, paragraphIx);
+        const sourceTree = this.getSentence(sourceText, response.originalSentenceRanges, response.sourceWordRanges, paragraphIx);
+        this.findSiblings(response.wordAlignment, sourceTree.words, targetTree.words);
+        return { sourceTree: sourceTree.tree, targetTree: targetTree.tree };
+    }
+    getSentence(text, sentenceRanges, wordRanges, paragraphIx) {
+        const tree = { text: text, children: [], paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: text };
+        const words = [];
+        let wordRangeIx = -1;
+        let lastProcessedCharIx = 0;
+        sentenceRanges.forEach((sentenceRange, sentenceIx) => {
+            const sentenceString = this.getSentenceFromRange(sentenceRange, text);
+            tree.children[sentenceIx] = {
+                text: sentenceString, children: [],
+                class: `${HighlightParams.sentenceClass} ${HighlightParams.sentenceClass}-${paragraphIx}-${sentenceIx}`,
+                elementId: sentenceIx.toString(),
+                type: HighlightTreeType.SENTENCE,
+                root: tree,
+                originalText: sentenceString
+            };
+            const sentenceStartIx = sentenceRange[0];
+            const sentenceEndIx = sentenceStartIx + sentenceRange[1];
+            let multipleWordWrapper;
+            for (let wordIx = wordRangeIx + 1; wordIx < wordRanges.length; wordIx++) {
+                const wordStartIx = wordRanges[wordIx][0];
+                const wordEndIx = wordRanges[wordIx][1];
+                const nextWordStartIx = wordRanges[wordIx + 1]?.[0];
+                if (wordStartIx >= sentenceStartIx && wordEndIx <= sentenceEndIx) {
+                    wordRangeIx = wordIx;
+                    if (lastProcessedCharIx < wordStartIx) {
+                        // words are not together anymore.
+                        multipleWordWrapper = null;
+                        const originalText = text.slice(lastProcessedCharIx, wordStartIx);
+                        // not a word.
+                        const escaped = Common.escapeHtmlString(originalText);
+                        tree.children[sentenceIx].children.push({
+                            text: escaped,
+                            type: HighlightTreeType.OTHER,
+                            root: tree,
+                            originalText
+                        });
+                        lastProcessedCharIx = wordStartIx;
+                    }
+                    const originalText = text.slice(wordStartIx, wordEndIx);
+                    const escaped = Common.escapeHtmlString(originalText);
+                    const elementId = `${paragraphIx}-${sentenceIx}-${wordIx}`;
+                    const word = {
+                        text: escaped,
+                        class: `${HighlightParams.wordClass} ${HighlightParams.wordClass}-${elementId}`,
+                        elementId: elementId,
+                        type: originalText === "-" ? HighlightTreeType.HYPEN : HighlightTreeType.WORD,
+                        root: tree,
+                        originalText
+                    };
+                    if (word.type === HighlightTreeType.HYPEN) {
+                        multipleWordWrapper = null;
+                    }
+                    else if (wordEndIx === nextWordStartIx) {
+                        if (!multipleWordWrapper) {
+                            multipleWordWrapper = {
+                                originalText: "",
+                                root: tree,
+                                text: "",
+                                type: HighlightTreeType.WORD_WRAPPER,
+                                children: [],
+                                class: HighlightParams.multipleWordWrapper
+                            };
+                            tree.children[sentenceIx].children.push(multipleWordWrapper);
+                        }
+                    }
+                    if (multipleWordWrapper) {
+                        multipleWordWrapper.originalText += originalText;
+                        multipleWordWrapper.text += escaped;
+                        multipleWordWrapper.children.push(word);
+                    }
+                    else {
+                        tree.children[sentenceIx].children.push(word);
+                    }
+                    words.push(word);
+                    lastProcessedCharIx = wordEndIx;
+                }
+                else {
+                    break;
+                }
+            }
+        });
+        return { tree, words };
+    }
+    getSentenceFromRange(range, text) {
+        const start = range[0] == 0 ? range[0] : range[0] + 1;
+        const end = start + range[1];
+        return text.slice(start, end);
+    }
+    findSiblings(wordAlignment, sourceWords, targetWords) {
+        wordAlignment.forEach((range) => {
+            const sourceWordIx = range[0];
+            const targetWordIx = range[1];
+            const sourceWord = sourceWords[sourceWordIx];
+            const targetWord = targetWords[targetWordIx];
+            if (sourceWord && targetWord) {
+                sourceWord.class += ` ${HighlightParams.siblingClass}-${targetWord.elementId}`;
+                targetWord.class += ` ${HighlightParams.siblingClass}-${sourceWord.elementId}`;
+            }
+        });
+    }
+}
+TldTranslateTextApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextApiService, deps: [{ token: i1.TldTermCollectionsService }, { token: i2.HttpClient }, { token: i3.TldTranslateConfigService }, { token: i3.TldAlertService }], target: i0.ɵɵFactoryTarget.Injectable });
+TldTranslateTextApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextApiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TldTermCollectionsService }, { type: i2.HttpClient }, { type: i3.TldTranslateConfigService }, { type: i3.TldAlertService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tld-translate-text-api.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tld-translate/src/lib/modules/tld-text/services/api/tld-translate-text-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { Common, ITldTranslateTextApiService, ITranslateParagraphRequestParams } from '../../../tld-common/models';\r\nimport { TldAlertService, TldTranslateConfigService } from '../../../tld-common/services';\r\nimport { TldTermCollectionsService } from '../../../tld-term/services';\r\nimport { IGetSentenceV1ResponseModel } from '../../models/get-sentence-v1-response.model';\r\nimport { HighlightParams } from '../../models/highlight-params.model';\r\nimport { HighlightTreeType } from '../../models/highlight-tree-type.model';\r\nimport { IHighlightTree } from '../../models/highlight-tree.model';\r\nimport { ITranslateParagraphResponseV1 } from '../../models/translate-paragraph-response-v1.model';\r\nimport { ITranslateParagraphResponse } from '../../models/translate-paragraph-response.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TldTranslateTextApiService implements ITldTranslateTextApiService {\r\n\r\n  constructor(private readonly collectionService: TldTermCollectionsService,\r\n    private readonly http: HttpClient,\r\n    private readonly config: TldTranslateConfigService,\r\n    private readonly alerts: TldAlertService) { }\r\n\r\n  updateTranslation(options: string, systemID: string, text: string, translation: string) {\r\n    const url = this.config.textConfig.updateTranslationUrl;\r\n    const headers = Common.getAuthHeaders(this.config);\r\n    const params = {\r\n      appID: this.config.coreConfig.appId,\r\n      options,\r\n      systemID,\r\n      text,\r\n      translation\r\n    }\r\n    return this.http.post(url, params, { headers });\r\n  }\r\n\r\n  dictionaryTranslation(text: string, srcCode: string, trgCode: string) {\r\n    const authHeaders = Common.getAuthHeaders(this.config);\r\n    // TODO. Create type for params.\r\n    const params: any = {\r\n      word: text,\r\n      sourceLanguage: srcCode,\r\n      targetLanguage: trgCode\r\n    };\r\n\r\n    return this.http.get(this.config.textConfig.dictionaryUrl, { headers: authHeaders, params: params })\r\n  }\r\n\r\n  translateParagraph(requestParams: ITranslateParagraphRequestParams): Observable<ITranslateParagraphResponse> {\r\n    const headers = Common.getAuthHeaders(this.config);\r\n    // TODO. Create type for params.\r\n    const params: any = {\r\n      appID: this.config.coreConfig.appId,\r\n      options: \"widget=text,alignment,markSentences\",\r\n      systemID: requestParams.system.id,\r\n      text: requestParams.text,\r\n    };\r\n\r\n    const selectedCollectionId = this.collectionService.selectedIdForTranslation();\r\n    if (selectedCollectionId) {\r\n      params.options += `,termCorpusId=${selectedCollectionId}`;\r\n    }\r\n\r\n    return this.http.get<ITranslateParagraphResponseV1>(this.config?.textConfig?.translationUrl, { headers: headers, params: params }).pipe(\r\n      map((response: ITranslateParagraphResponseV1) => {\r\n        if (response.ErrorMessage) {\r\n          this.alerts.unhandeledError(response.ErrorMessage);\r\n          throw response.ErrorMessage;\r\n        }\r\n        const converted = this.convertParagraphResponse(requestParams, response);\r\n        return converted;\r\n      })\r\n    );\r\n  }\r\n\r\n\r\n  private convertParagraphResponse(request: ITranslateParagraphRequestParams, response: ITranslateParagraphResponseV1): ITranslateParagraphResponse {\r\n    if (this.config.textConfig.highlight) {\r\n      return this.createHighlightTrees(request.text, response, request.paragraphIx);\r\n    }\r\n    else {\r\n      return {\r\n        sourceTree: { text: request.text, paragraphIx: request.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: request.text },\r\n        targetTree: { text: response.translation, paragraphIx: request.paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: response.translation }\r\n      };\r\n    }\r\n  }\r\n\r\n  private createHighlightTrees(sourceText: string, response: ITranslateParagraphResponseV1, paragraphIx: number): ITranslateParagraphResponse {\r\n    const targetTree = this.getSentence(response.translation, response.translationSentenceRanges, response.targetWordRanges, paragraphIx);\r\n    const sourceTree = this.getSentence(sourceText, response.originalSentenceRanges, response.sourceWordRanges, paragraphIx);\r\n    this.findSiblings(response.wordAlignment, sourceTree.words, targetTree.words);\r\n    return { sourceTree: sourceTree.tree, targetTree: targetTree.tree };\r\n  }\r\n\r\n  private getSentence(text: string, sentenceRanges: number[][], wordRanges: number[][], paragraphIx: number): IGetSentenceV1ResponseModel {\r\n    const tree: IHighlightTree = { text: text, children: [], paragraphIx, type: HighlightTreeType.PARAGRAPH, root: null, originalText: text };\r\n    const words: IHighlightTree[] = [];\r\n    let wordRangeIx = -1;\r\n    let lastProcessedCharIx = 0;\r\n\r\n    sentenceRanges.forEach((sentenceRange, sentenceIx) => {\r\n      const sentenceString = this.getSentenceFromRange(sentenceRange, text);\r\n      tree.children[sentenceIx] = {\r\n        text: sentenceString, children: [],\r\n        class: `${HighlightParams.sentenceClass} ${HighlightParams.sentenceClass}-${paragraphIx}-${sentenceIx}`,\r\n        elementId: sentenceIx.toString(),\r\n        type: HighlightTreeType.SENTENCE,\r\n        root: tree,\r\n        originalText: sentenceString\r\n      };\r\n\r\n      const sentenceStartIx = sentenceRange[0];\r\n      const sentenceEndIx = sentenceStartIx + sentenceRange[1];\r\n\r\n      let multipleWordWrapper: IHighlightTree;\r\n      for (let wordIx = wordRangeIx + 1; wordIx < wordRanges.length; wordIx++) {\r\n        const wordStartIx = wordRanges[wordIx][0];\r\n        const wordEndIx = wordRanges[wordIx][1];\r\n        const nextWordStartIx = wordRanges[wordIx + 1]?.[0];\r\n\r\n        if (wordStartIx >= sentenceStartIx && wordEndIx <= sentenceEndIx) {\r\n          wordRangeIx = wordIx;\r\n          if (lastProcessedCharIx < wordStartIx) {\r\n            // words are not together anymore.\r\n            multipleWordWrapper = null;\r\n            const originalText = text.slice(lastProcessedCharIx, wordStartIx);\r\n            // not a word.\r\n            const escaped = Common.escapeHtmlString(originalText);\r\n            tree.children[sentenceIx].children.push({\r\n              text: escaped,\r\n              type: HighlightTreeType.OTHER,\r\n              root: tree,\r\n              originalText\r\n            });\r\n            lastProcessedCharIx = wordStartIx;\r\n          }\r\n          const originalText = text.slice(wordStartIx, wordEndIx);\r\n          const escaped = Common.escapeHtmlString(originalText);\r\n          const elementId = `${paragraphIx}-${sentenceIx}-${wordIx}`;\r\n          const word: IHighlightTree = {\r\n            text: escaped,\r\n            class: `${HighlightParams.wordClass} ${HighlightParams.wordClass}-${elementId}`,\r\n            elementId: elementId,\r\n            type: originalText === \"-\" ? HighlightTreeType.HYPEN : HighlightTreeType.WORD,\r\n            root: tree,\r\n            originalText\r\n          };\r\n\r\n          if (word.type === HighlightTreeType.HYPEN) {\r\n            multipleWordWrapper = null;\r\n          }\r\n          else if (wordEndIx === nextWordStartIx) {\r\n            if (!multipleWordWrapper) {\r\n              multipleWordWrapper = {\r\n                originalText: \"\",\r\n                root: tree,\r\n                text: \"\",\r\n                type: HighlightTreeType.WORD_WRAPPER,\r\n                children: [],\r\n                class: HighlightParams.multipleWordWrapper\r\n              }\r\n              tree.children[sentenceIx].children.push(multipleWordWrapper);\r\n            }\r\n          }\r\n          if (multipleWordWrapper) {\r\n            multipleWordWrapper.originalText += originalText;\r\n            multipleWordWrapper.text += escaped;\r\n            multipleWordWrapper.children.push(word);\r\n          }\r\n          else {\r\n            tree.children[sentenceIx].children.push(word);\r\n          }\r\n          words.push(word);\r\n          lastProcessedCharIx = wordEndIx;\r\n        }\r\n        else {\r\n          break;\r\n        }\r\n      }\r\n    })\r\n    return { tree, words };\r\n  }\r\n\r\n  private getSentenceFromRange(range: number[], text: string): string {\r\n    const start = range[0] == 0 ? range[0] : range[0] + 1;\r\n    const end = start + range[1];\r\n    return text.slice(start, end);\r\n  }\r\n\r\n  private findSiblings(wordAlignment: number[][], sourceWords: IHighlightTree[], targetWords: IHighlightTree[]) {\r\n    wordAlignment.forEach((range) => {\r\n      const sourceWordIx = range[0];\r\n      const targetWordIx = range[1];\r\n      const sourceWord = sourceWords[sourceWordIx];\r\n      const targetWord = targetWords[targetWordIx];\r\n\r\n      if (sourceWord && targetWord) {\r\n        sourceWord.class += ` ${HighlightParams.siblingClass}-${targetWord.elementId}`;\r\n        targetWord.class += ` ${HighlightParams.siblingClass}-${sourceWord.elementId}`;\r\n      }\r\n    })\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,110 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { Common } from '../../../tld-common/models';
+import { HighlightParams } from '../../models/highlight-params.model';
+import { HighlightTreeType } from '../../models/highlight-tree-type.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../tld-common/services";
+export class TldTranslateTextApiV2Service {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+    }
+    translateParagraph(params) {
+        const requestParams = {
+            domain: params.system.domain,
+            srcLang: params.system.sourceLanguage,
+            text: [params.text],
+            trgLang: params.system.targetLanguage
+        };
+        const sourceText = params.text;
+        const sourceTree = {
+            text: Common.escapeHtmlString(sourceText),
+            paragraphIx: params.paragraphIx,
+            type: HighlightTreeType.PARAGRAPH,
+            root: null,
+            originalText: sourceText
+        };
+        const headers = Common.GetApiV2AuthHeaders(this.config);
+        if (this.config.textConfig.checkSourceGrammar && this.config.textConfig.grammarCheckLanguages.includes(params.system.sourceLanguage)) {
+            this.checkAndAttachGrammarToTree(params.text, params.system.sourceLanguage, sourceTree);
+        }
+        return this.http.post(this.config.apiV2Config.translationUrl, requestParams, { headers }).pipe(map((translationResponse) => {
+            const systemId = `${requestParams.srcLang}-${requestParams.trgLang}-${translationResponse.domain}`;
+            const originalTranslation = translationResponse.translations[0].translation;
+            const targetTree = {
+                text: Common.escapeHtmlString(originalTranslation),
+                paragraphIx: params.paragraphIx,
+                type: HighlightTreeType.PARAGRAPH,
+                root: null,
+                originalText: originalTranslation
+            };
+            return {
+                sourceTree,
+                targetTree,
+                systemId
+            };
+        }));
+    }
+    checkGrammar(text, language) {
+        return this.http.post(this.config.apiV2Config.grammarCheckUrl, { text, language });
+    }
+    checkAndAttachGrammarToTree(text, language, tree) {
+        this.checkGrammar(text, language)
+            .pipe(catchError((error) => {
+            console.error(error);
+            return of(null);
+        }))
+            .subscribe((grammarCheckResponse) => {
+            if (grammarCheckResponse?.corrections?.length > 0) {
+                tree.children = [];
+                let lastIx = 0;
+                grammarCheckResponse.corrections.forEach((correction) => {
+                    const wordStartIx = correction.span.start;
+                    const wordEndIx = correction.span.end;
+                    if (lastIx < wordStartIx) {
+                        const originalText = text.slice(lastIx, wordStartIx);
+                        const escaped = Common.escapeHtmlString(originalText);
+                        tree.children.push({ text: escaped, originalText, type: HighlightTreeType.OTHER, root: tree });
+                    }
+                    const originalText = text.slice(wordStartIx, wordEndIx);
+                    const child = {
+                        text: Common.escapeHtmlString(text.slice(wordStartIx, wordEndIx)),
+                        class: `${HighlightParams.invalidPhraseClass}`,
+                        grammarMeta: {
+                            startIx: wordStartIx,
+                            endIx: wordEndIx,
+                            replacements: correction.replacements.map(el => el.value)
+                        },
+                        type: HighlightTreeType.OTHER,
+                        root: tree,
+                        originalText
+                    };
+                    tree.children.push(child);
+                    lastIx = wordEndIx;
+                });
+                if (lastIx != text.length - 1) {
+                    const originalText = text.slice(lastIx, text.length - 1);
+                    tree.children.push({
+                        text: Common.escapeHtmlString(originalText),
+                        type: HighlightTreeType.OTHER,
+                        root: tree,
+                        originalText
+                    });
+                }
+                tree.children.push();
+            }
+        });
+    }
+}
+TldTranslateTextApiV2Service.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextApiV2Service, deps: [{ token: i1.HttpClient }, { token: i2.TldTranslateConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+TldTranslateTextApiV2Service.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextApiV2Service, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTranslateTextApiV2Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TldTranslateConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tld-translate-text-api-v2.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tld-translate/src/lib/modules/tld-text/services/api-v2/tld-translate-text-api-v2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, of } from 'rxjs';\r\nimport { catchError, map } from 'rxjs/operators';\r\nimport { Common, ITldTranslateTextApiService, ITranslateParagraphRequestParams } from '../../../tld-common/models';\r\nimport { TldTranslateConfigService } from '../../../tld-common/services';\r\nimport { ICheckGrammarResponseV2 } from '../../models/check-grammar-response-v2.model';\r\nimport { HighlightParams } from '../../models/highlight-params.model';\r\nimport { HighlightTreeType } from '../../models/highlight-tree-type.model';\r\nimport { IHighlightTree } from '../../models/highlight-tree.model';\r\nimport { ITranslateParagraphParams } from '../../models/translate-paragraph-params.model';\r\nimport { ITranslateParagraphResponseV2 } from '../../models/translate-paragraph-response-v2.model';\r\nimport { ITranslateParagraphResponse } from '../../models/translate-paragraph-response.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TldTranslateTextApiV2Service implements ITldTranslateTextApiService {\r\n\r\n  constructor(private readonly http: HttpClient,\r\n    private readonly config: TldTranslateConfigService) { }\r\n\r\n  translateParagraph(params: ITranslateParagraphRequestParams): Observable<ITranslateParagraphResponse> {\r\n    const requestParams: ITranslateParagraphParams = {\r\n      domain: params.system.domain,\r\n      srcLang: params.system.sourceLanguage,\r\n      text: [params.text],\r\n      trgLang: params.system.targetLanguage\r\n    };\r\n    const sourceText = params.text;\r\n    const sourceTree: IHighlightTree = {\r\n      text: Common.escapeHtmlString(sourceText),\r\n      paragraphIx: params.paragraphIx,\r\n      type: HighlightTreeType.PARAGRAPH,\r\n      root: null,\r\n      originalText: sourceText\r\n    };\r\n    const headers = Common.GetApiV2AuthHeaders(this.config);\r\n\r\n    if (this.config.textConfig.checkSourceGrammar && this.config.textConfig.grammarCheckLanguages.includes(params.system.sourceLanguage)) {\r\n      this.checkAndAttachGrammarToTree(params.text, params.system.sourceLanguage, sourceTree);\r\n    }\r\n\r\n    return this.http.post<ITranslateParagraphResponseV2>(this.config.apiV2Config.translationUrl, requestParams, { headers }).pipe(\r\n      map((translationResponse) => {\r\n        const systemId = `${requestParams.srcLang}-${requestParams.trgLang}-${translationResponse.domain}`;\r\n        const originalTranslation = translationResponse.translations[0].translation;\r\n        const targetTree: IHighlightTree = {\r\n          text: Common.escapeHtmlString(originalTranslation),\r\n          paragraphIx: params.paragraphIx,\r\n          type: HighlightTreeType.PARAGRAPH,\r\n          root: null,\r\n          originalText: originalTranslation\r\n        };\r\n        return {\r\n          sourceTree,\r\n          targetTree,\r\n          systemId\r\n        };\r\n      })\r\n    );\r\n  }\r\n\r\n  checkGrammar(text: string, language: string): Observable<ICheckGrammarResponseV2> {\r\n    return this.http.post<ICheckGrammarResponseV2>(this.config.apiV2Config.grammarCheckUrl, { text, language });\r\n  }\r\n\r\n  private checkAndAttachGrammarToTree(text: string, language: string, tree: IHighlightTree) {\r\n    this.checkGrammar(text, language)\r\n      .pipe(\r\n        catchError((error) => {\r\n          console.error(error);\r\n          return of(null)\r\n        })\r\n      )\r\n      .subscribe((grammarCheckResponse) => {\r\n        if (grammarCheckResponse?.corrections?.length > 0) {\r\n          tree.children = [];\r\n          let lastIx = 0;\r\n          grammarCheckResponse.corrections.forEach((correction) => {\r\n            const wordStartIx = correction.span.start;\r\n            const wordEndIx = correction.span.end;\r\n            if (lastIx < wordStartIx) {\r\n              const originalText = text.slice(lastIx, wordStartIx);\r\n              const escaped = Common.escapeHtmlString(originalText);\r\n              tree.children.push({ text: escaped, originalText, type: HighlightTreeType.OTHER, root: tree });\r\n            }\r\n\r\n            const originalText = text.slice(wordStartIx, wordEndIx);\r\n            const child: IHighlightTree = {\r\n              text: Common.escapeHtmlString(text.slice(wordStartIx, wordEndIx)),\r\n              class: `${HighlightParams.invalidPhraseClass}`,\r\n              grammarMeta: {\r\n                startIx: wordStartIx,\r\n                endIx: wordEndIx,\r\n                replacements: correction.replacements.map(el => el.value)\r\n              },\r\n              type: HighlightTreeType.OTHER,\r\n              root: tree,\r\n              originalText\r\n            }\r\n            tree.children.push(child)\r\n            lastIx = wordEndIx;\r\n          });\r\n          if (lastIx != text.length - 1) {\r\n            const originalText = text.slice(lastIx, text.length - 1);\r\n            tree.children.push(\r\n              {\r\n                text: Common.escapeHtmlString(originalText),\r\n                type: HighlightTreeType.OTHER,\r\n                root: tree,\r\n                originalText\r\n              })\r\n          }\r\n          tree.children.push()\r\n        }\r\n      });\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,2 @@
+export * from './tld-translate-text.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGV4dC9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90bGQtdHJhbnNsYXRlLXRleHQuc2VydmljZSc7XHJcbiJdfQ==