@creativeorange/azure-text-to-speech 2.2.3 → 3.0.0

package/package.json

@@ -1,23 +1,41 @@
 {
   "name": "@creativeorange/azure-text-to-speech",
-  "version": "2.2.3",
+  "version": "3.0.0",
   "main": "dist/co-azure-tts.umd.js",
   "browser": "dist/co-azure-tts.es.js",
+  "module": "dist/co-azure-tts.es.js",
+  "exports": {
+    ".": {
+      "import": "./dist/co-azure-tts.es.js",
+      "require": "./dist/co-azure-tts.umd.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "scripts": {
-    "build": "vite build --watch"
+    "build": "vite build",
+    "build:watch": "vite build --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint \"src/**/*.ts\" \"tests/**/*.ts\""
   },
   "license": "MIT",
   "author": "Edsardio",
   "devDependencies": {
     "@originjs/vite-plugin-commonjs": "^1.0.1",
     "@typescript-eslint/eslint-plugin": "^5.33.0",
+    "@typescript-eslint/parser": "^5.33.0",
     "build-esm": "^4.2.2",
     "eslint": "^8.21.0",
     "eslint-config-google": "^0.14.0",
+    "jsdom": "^24.1.0",
     "microsoft-cognitiveservices-speech-sdk": "^1.22.0",
     "typescript": "^4.7.4",
     "vite": "^2.7.2",
     "vite-plugin-env-compatible": "^1.1.1",
-    "vite-plugin-eslint": "^1.7.0"
+    "vite-plugin-eslint": "^1.7.0",
+    "vitest": "^0.34.6"
   }
 }

package/src/SpeechToText.ts

@@ -4,19 +4,36 @@ import {
     TranslationRecognizer,
     ResultReason,
 } from 'microsoft-cognitiveservices-speech-sdk';
+import {
+    SpeechAuthenticationOptions,
+    SpeechAuthorizationManager,
+    toSafeErrorDetail,
+} from './authentication';
+
+export type SpeechToTextOptions = SpeechAuthenticationOptions & {
+    region?: string;
+    sourceLanguage: string;
+    targetLanguage?: string;
+};
 
 export class SpeechToText {
-    key: string;
     region: string;
     sourceLanguage: string;
     targetLanguage: string;
     recognizer: TranslationRecognizer | undefined;
 
-    constructor(key: string, region: string, sourceLanguage: string, targetLanguage: string|null = null) {
-        this.key = key;
-        this.region = region;
-        this.sourceLanguage = sourceLanguage;
-        this.targetLanguage = (targetLanguage !== null) ? targetLanguage : sourceLanguage;
+    private readonly authorizationManager: SpeechAuthorizationManager;
+
+    constructor(options: SpeechToTextOptions) {
+        if (!options || typeof options.sourceLanguage !== 'string' ||
+            options.sourceLanguage.trim() === '') {
+            throw new Error('A sourceLanguage is required.');
+        }
+
+        this.authorizationManager = new SpeechAuthorizationManager(options);
+        this.region = options.region?.trim() ?? '';
+        this.sourceLanguage = options.sourceLanguage;
+        this.targetLanguage = options.targetLanguage ?? options.sourceLanguage;
     }
 
     async start() {
@@ -46,46 +63,70 @@ export class SpeechToText {
         }
     }
 
-    async handleStartModifier(node: any, attr: Attr) {
-        node.addEventListener('click', async (_: any) => {
-            const speechConfig = SpeechTranslationConfig.fromSubscription(this.key, this.region);
-            speechConfig.speechRecognitionLanguage = this.sourceLanguage;
-            speechConfig.addTargetLanguage(this.targetLanguage);
+    private async createSpeechTranslationConfig():
+        Promise<SpeechTranslationConfig> {
+        const authorization =
+            await this.authorizationManager.getAuthorization();
 
-            const audioConfig = AudioConfig.fromDefaultMicrophoneInput();
+        const speechConfig =
+            SpeechTranslationConfig.fromAuthorizationToken(
+                authorization.token,
+                authorization.region,
+            );
 
-            this.recognizer = new TranslationRecognizer(speechConfig, audioConfig);
+        speechConfig.speechRecognitionLanguage =
+            this.sourceLanguage;
 
-            document.dispatchEvent(new CustomEvent('COAzureSTTStartedRecording', {}));
+        speechConfig.addTargetLanguage(
+            this.targetLanguage,
+        );
 
-            const prevResults = [];
-            this.recognizer.recognizing = (sender, event) => {
-                const result = event.result;
+        this.region = authorization.region;
 
-                if (result && result.reason === ResultReason.TranslatingSpeech) {
-                    const translation = result.translations.get(this.targetLanguage);
-                    prevResults['result_' +result.privOffset.toString()] = translation;
-                    const totalResult = Object.values(prevResults).join('. ');
+        return speechConfig;
+    }
 
-                    const inputElement = document.getElementById(attr.value);
-                    if (inputElement !== null) {
-                        if (inputElement instanceof HTMLInputElement) {
-                            inputElement.value = `${totalResult} `;
-                        } else {
-                            inputElement.innerHTML = `${totalResult} `;
+    async handleStartModifier(node: any, attr: Attr) {
+        node.addEventListener('click', async (_: any) => {
+            try {
+                const speechConfig = await this.createSpeechTranslationConfig();
+                const audioConfig = AudioConfig.fromDefaultMicrophoneInput();
+
+                this.recognizer = new TranslationRecognizer(speechConfig, audioConfig);
+
+                document.dispatchEvent(new CustomEvent('COAzureSTTStartedRecording', {}));
+
+                const prevResults = [];
+                this.recognizer.recognizing = (sender, event) => {
+                    const result = event.result;
+
+                    if (result && result.reason === ResultReason.TranslatingSpeech) {
+                        const translation = result.translations.get(this.targetLanguage);
+                        prevResults['result_' +result.privOffset.toString()] = translation;
+                        const totalResult = Object.values(prevResults).join('. ');
+
+                        const inputElement = document.getElementById(attr.value);
+                        if (inputElement !== null) {
+                            if (inputElement instanceof HTMLInputElement) {
+                                inputElement.value = `${totalResult} `;
+                            } else {
+                                inputElement.innerHTML = `${totalResult} `;
+                            }
                         }
                     }
-                }
-            };
-
-            this.recognizer.startContinuousRecognitionAsync(
-                (result) => {},
-                (err) => {
-                    console.log(err);
-
-                    this.stop();
-                }
-            );
+                };
+
+                this.recognizer.startContinuousRecognitionAsync(
+                    () => {},
+                    (err) => {
+                        this.dispatchError(err, 'RECOGNITION_ERROR');
+                        this.stop();
+                    },
+                );
+            } catch (error) {
+                this.dispatchError(error);
+                await this.stop();
+            }
         });
     }
 
@@ -97,10 +138,35 @@ export class SpeechToText {
 
     async stop() {
         if (this.recognizer !== undefined) {
-            this.recognizer.stopContinuousRecognitionAsync();
-            this.recognizer.close();
+            try {
+                this.recognizer.stopContinuousRecognitionAsync();
+            } catch {
+                // Recognizer may already be stopping.
+            }
+
+            try {
+                this.recognizer.close();
+            } catch {
+                // Recognizer may already be closed.
+            }
+
             this.recognizer = undefined;
         }
         document.dispatchEvent(new CustomEvent('COAzureSTTStoppedRecording', {}));
     }
+
+    private dispatchError(error: unknown, code?: string) {
+        const detail = toSafeErrorDetail(error);
+        if (code && !detail.code) {
+            detail.code = code;
+        }
+
+        document.dispatchEvent(
+            new CustomEvent('COAzureSTTError', {
+                detail: {
+                    error: detail,
+                },
+            }),
+        );
+    }
 }