All files / src/utils ambiguity-detection.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import {comprehend} from "./comprehend";
import {translate} from "./translation";
import type {Phrase, TranscriptPart} from "../../amplify/utils/types.ts";
 
export async function detectAmbiguity(transcript: TranscriptPart[]): Promise<Phrase[]> {
    const ambiguousWords: Phrase[] = [];
    for (const part of transcript) {
        const translateKP = await comprehend(
            part.translatedText,
            part.translatedLanguage.translateCode,
        );
        const translateKPSet = [];
        for (const phrase of translateKP) {
            const text = phrase.Text;
            if (text === undefined) {
                continue;
            }
            translateKPSet.push(phrase.Text!.toLowerCase());
        }
 
        for (const phrase of translateKP) {
            const text = phrase.Text;
            const beginOffset = phrase.BeginOffset;
            const endOffset = phrase.EndOffset;
            if (text === undefined || beginOffset === undefined || endOffset === undefined) {
                continue;
            }
            const backOriginalPhrase = await translate(
                text,
                part.translatedLanguage.translateCode,
                part.language.translateCode,
            );
            const backTranslatedPhrase = await translate(
                backOriginalPhrase,
                part.language.translateCode,
                part.translatedLanguage.translateCode,
            );
            if (!translateKPSet.includes(backTranslatedPhrase.toLowerCase())) {
                const ambiguousWord: Phrase = {
                    text: text,
                    beginOffset: beginOffset,
                    endOffset: endOffset,
                    alternateDefinition: backTranslatedPhrase,
                };
                let exists = false;
                for (const amb of ambiguousWords) {
                    if (amb.text === ambiguousWord.text && amb.beginOffset === ambiguousWord.beginOffset) {
                        exists = true;
                    }
                }
                if (!exists) {
                    ambiguousWords.push(ambiguousWord);
                }
            }
        }
    }
    return ambiguousWords;
}