web-speech-cognitive-services 8.0.0-main.428d2a8 → 8.0.0-main.5903868

package/dist/web-speech-cognitive-services.mjs

@@ -1,6 +1,3 @@
-// src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.js
-import { Event, EventTarget, getEventAttributeValue, setEventAttributeValue } from "event-target-shim";
-
 // ../../node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -135,53 +132,111 @@ var SpeechSDK_default = {
   SpeechRecognizer
 };
 
-// src/Util/arrayToMap.js
-function arrayToMap_default(array, extras) {
-  const map = {
-    ...[].reduce.call(
-      array,
-      (map2, value, index) => {
-        map2[index] = value;
-        return map2;
-      },
-      {}
-    ),
-    ...extras,
-    length: array.length,
-    [Symbol.iterator]: () => [].slice.call(map)[Symbol.iterator]()
-  };
-  return map;
-}
+// src/SpeechServices/SpeechToText/SpeechRecognitionAlternative.ts
+var SpeechRecognitionAlternative = class {
+  constructor({ confidence, transcript }) {
+    this.#confidence = confidence;
+    this.#transcript = transcript;
+  }
+  #confidence;
+  #transcript;
+  get confidence() {
+    return this.#confidence;
+  }
+  get transcript() {
+    return this.#transcript;
+  }
+};
+
+// src/SpeechServices/SpeechToText/FakeArray.ts
+var FakeArray = class {
+  constructor(array) {
+    if (!array) {
+      throw new Error("array must be set.");
+    }
+    this.#array = array;
+    for (const key in array) {
+      Object.defineProperty(this, key, {
+        enumerable: true,
+        get() {
+          return array[key];
+        }
+      });
+    }
+  }
+  #array;
+  [Symbol.iterator]() {
+    return this.#array[Symbol.iterator]();
+  }
+  get length() {
+    return this.#array.length;
+  }
+};
+
+// src/SpeechServices/SpeechToText/SpeechRecognitionResult.ts
+var SpeechRecognitionResult = class extends FakeArray {
+  constructor(init) {
+    super(init.results);
+    this.#isFinal = init.isFinal;
+  }
+  #isFinal;
+  get isFinal() {
+    return this.#isFinal;
+  }
+};
 
-// src/SpeechServices/SpeechToText/cognitiveServiceEventResultToWebSpeechRecognitionResultList.js
+// src/SpeechServices/SpeechToText/cognitiveServiceEventResultToWebSpeechRecognitionResult.ts
 var {
   ResultReason: { RecognizingSpeech, RecognizedSpeech }
 } = SpeechSDK_default;
-function cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(result, { maxAlternatives = Infinity, textNormalization = "display" } = {}) {
-  if (result.reason === RecognizingSpeech || result.reason === RecognizedSpeech && !result.json.NBest) {
-    const resultList = [
-      {
-        confidence: 0.5,
-        transcript: result.text
-      }
-    ];
-    if (result.reason === RecognizedSpeech) {
-      resultList.isFinal = true;
-    }
-    return resultList;
+function cognitiveServiceEventResultToWebSpeechRecognitionResult_default(result, init) {
+  const { maxAlternatives = Infinity, textNormalization = "display" } = init || {};
+  const json = typeof result.json === "string" ? JSON.parse(result.json) : result.json;
+  if (result.reason === RecognizingSpeech || result.reason === RecognizedSpeech && !json.NBest) {
+    return new SpeechRecognitionResult({
+      isFinal: result.reason === RecognizedSpeech,
+      results: [
+        new SpeechRecognitionAlternative({
+          confidence: 0.5,
+          transcript: result.text
+        })
+      ]
+    });
   } else if (result.reason === RecognizedSpeech) {
-    const resultList = arrayToMap_default(
-      (result.json.NBest || []).slice(0, maxAlternatives).map(({ Confidence: confidence, Display: display, ITN: itn, Lexical: lexical, MaskedITN: maskedITN }) => ({
-        confidence,
-        transcript: textNormalization === "itn" ? itn : textNormalization === "lexical" ? lexical : textNormalization === "maskeditn" ? maskedITN : display
-      })),
-      { isFinal: true }
-    );
-    return resultList;
+    return new SpeechRecognitionResult({
+      isFinal: true,
+      results: (json.NBest || []).slice(0, maxAlternatives).map(
+        ({ Confidence: confidence, Display: display, ITN: itn, Lexical: lexical, MaskedITN: maskedITN }) => new SpeechRecognitionAlternative({
+          confidence,
+          transcript: textNormalization === "itn" ? itn : textNormalization === "lexical" ? lexical : textNormalization === "maskeditn" ? maskedITN : display
+        })
+      )
+    });
   }
-  return [];
+  return new SpeechRecognitionResult({ isFinal: false, results: [] });
 }
 
+// src/SpeechServices/SpeechToText/EventListenerMap.ts
+var EventListenerMap = class {
+  constructor(eventTarget) {
+    this.#eventTarget = eventTarget;
+    this.#propertyMap = {};
+  }
+  #eventTarget;
+  #propertyMap;
+  getProperty(name) {
+    return this.#propertyMap[name];
+  }
+  setProperty(name, value) {
+    const existing = this.#propertyMap[name];
+    existing && this.#eventTarget.removeEventListener(name, existing);
+    if (value) {
+      this.#eventTarget.addEventListener(name, value);
+    }
+    this.#propertyMap[name] = value;
+  }
+};
+
 // src/SpeechServices/SpeechToText/SpeechGrammarList.js
 var SpeechGrammarList_default = class {
   constructor() {
@@ -204,6 +259,53 @@ var SpeechGrammarList_default = class {
   }
 };
 
+// src/SpeechServices/SpeechToText/SpeechRecognitionErrorEvent.ts
+var SpeechRecognitionErrorEvent = class extends Event {
+  constructor(type, { error, message }) {
+    super(type);
+    this.#error = error;
+    this.#message = message;
+  }
+  #error;
+  #message;
+  get error() {
+    return this.#error;
+  }
+  get message() {
+    return this.#message;
+  }
+};
+
+// src/SpeechServices/SpeechToText/SpeechRecognitionResultList.ts
+var SpeechRecognitionResultList = class extends FakeArray {
+  constructor(result) {
+    super(result);
+  }
+};
+
+// src/SpeechServices/SpeechToText/SpeechRecognitionEvent.ts
+var SpeechRecognitionEvent = class extends Event {
+  constructor(type, { data, resultIndex, results } = {}) {
+    super(type);
+    this.#data = data;
+    this.#resultIndex = resultIndex;
+    this.#results = results || new SpeechRecognitionResultList([]);
+  }
+  #data;
+  // TODO: "resultIndex" should be set.
+  #resultIndex;
+  #results;
+  get data() {
+    return this.#data;
+  }
+  get resultIndex() {
+    return this.#resultIndex;
+  }
+  get results() {
+    return this.#results;
+  }
+};
+
 // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.js
 var { AudioConfig: AudioConfig2, OutputFormat: OutputFormat2, ResultReason: ResultReason2, SpeechConfig: SpeechConfig2, SpeechRecognizer: SpeechRecognizer2 } = SpeechSDK_default;
 function serializeRecognitionResult({ duration, errorDetails, json, offset, properties, reason, resultId, text }) {
@@ -225,16 +327,6 @@ function averageAmplitude(arrayBuffer) {
 function cognitiveServicesAsyncToPromise(fn) {
   return (...args) => new Promise((resolve, reject) => fn(...args, resolve, reject));
 }
-var SpeechRecognitionEvent = class extends Event {
-  constructor(type, { data, emma, interpretation, resultIndex, results } = {}) {
-    super(type);
-    this.data = data;
-    this.emma = emma;
-    this.interpretation = interpretation;
-    this.resultIndex = resultIndex;
-    this.results = results;
-  }
-};
 function prepareAudioConfig(audioConfig) {
   const originalAttach = audioConfig.attach;
   const boundOriginalAttach = audioConfig.attach.bind(audioConfig);
@@ -283,7 +375,10 @@ function createSpeechRecognitionPonyfillFromRecognizer({
       this._lang = typeof window !== "undefined" ? window.document.documentElement.getAttribute("lang") || window.navigator.language : "en-US";
       this._grammars = new SpeechGrammarList_default();
       this._maxAlternatives = 1;
+      this.#eventListenerMap = new EventListenerMap(this);
     }
+    /** @type { import('./SpeechRecognitionEventListenerMap').SpeechRecognitionEventListenerMap } */
+    #eventListenerMap;
     emitCognitiveServices(type, event) {
       this.dispatchEvent(
         new SpeechRecognitionEvent("cognitiveservices", {
@@ -328,75 +423,88 @@ function createSpeechRecognitionPonyfillFromRecognizer({
     set lang(value) {
       this._lang = value;
     }
+    /** @type { ((event: SpeechRecognitionEvent<'audioend'>) => void) | undefined } */
     get onaudioend() {
-      return getEventAttributeValue(this, "audioend");
+      return this.#eventListenerMap.getProperty("audioend");
     }
     set onaudioend(value) {
-      setEventAttributeValue(this, "audioend", value);
+      this.#eventListenerMap.setProperty("audioend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'audiostart'>) => void) | undefined } */
     get onaudiostart() {
-      return getEventAttributeValue(this, "audiostart");
+      return this.#eventListenerMap.getProperty("audiostart");
     }
     set onaudiostart(value) {
-      setEventAttributeValue(this, "audiostart", value);
+      this.#eventListenerMap.setProperty("audiostart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'cognitiveservices'>) => void) | undefined } */
     get oncognitiveservices() {
-      return getEventAttributeValue(this, "cognitiveservices");
+      return this.#eventListenerMap.getProperty("cognitiveservices");
     }
     set oncognitiveservices(value) {
-      setEventAttributeValue(this, "cognitiveservices", value);
+      this.#eventListenerMap.setProperty("cognitiveservices", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'end'>) => void) | undefined } */
     get onend() {
-      return getEventAttributeValue(this, "end");
+      return this.#eventListenerMap.getProperty("end");
     }
     set onend(value) {
-      setEventAttributeValue(this, "end", value);
+      this.#eventListenerMap.setProperty("end", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'error'>) => void) | undefined } */
     get onerror() {
-      return getEventAttributeValue(this, "error");
+      return this.#eventListenerMap.getProperty("error");
     }
     set onerror(value) {
-      setEventAttributeValue(this, "error", value);
+      this.#eventListenerMap.setProperty("error", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'result'>) => void) | undefined } */
     get onresult() {
-      return getEventAttributeValue(this, "result");
+      return this.#eventListenerMap.getProperty("result");
     }
     set onresult(value) {
-      setEventAttributeValue(this, "result", value);
+      this.#eventListenerMap.setProperty("result", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'soundend'>) => void) | undefined } */
     get onsoundend() {
-      return getEventAttributeValue(this, "soundend");
+      return this.#eventListenerMap.getProperty("soundend");
     }
     set onsoundend(value) {
-      setEventAttributeValue(this, "soundend", value);
+      this.#eventListenerMap.setProperty("soundend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'soundstart'>) => void) | undefined } */
     get onsoundstart() {
-      return getEventAttributeValue(this, "soundstart");
+      return this.#eventListenerMap.getProperty("soundstart");
     }
     set onsoundstart(value) {
-      setEventAttributeValue(this, "soundstart", value);
+      this.#eventListenerMap.setProperty("soundstart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'speechend'>) => void) | undefined } */
     get onspeechend() {
-      return getEventAttributeValue(this, "speechend");
+      return this.#eventListenerMap.getProperty("speechend");
     }
     set onspeechend(value) {
-      setEventAttributeValue(this, "speechend", value);
+      this.#eventListenerMap.setProperty("speechend", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'speechstart'>) => void) | undefined } */
     get onspeechstart() {
-      return getEventAttributeValue(this, "speechstart");
+      return this.#eventListenerMap.getProperty("speechstart");
     }
     set onspeechstart(value) {
-      setEventAttributeValue(this, "speechstart", value);
+      this.#eventListenerMap.setProperty("speechstart", value);
     }
+    /** @type { ((event: SpeechRecognitionEvent<'start'>) => void) | undefined } */
     get onstart() {
-      return getEventAttributeValue(this, "start");
+      return this.#eventListenerMap.getProperty("start");
     }
     set onstart(value) {
-      setEventAttributeValue(this, "start", value);
+      this.#eventListenerMap.setProperty("start", value);
     }
     start() {
       this._startOnce().catch((err) => {
-        this.dispatchEvent(new ErrorEvent("error", { error: err, message: err && (err.stack || err.message) }));
+        this.dispatchEvent(
+          new SpeechRecognitionErrorEvent("error", { error: err, message: err && (err.stack || err.message) })
+        );
       });
     }
     async _startOnce() {
@@ -486,10 +594,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
           Object.keys(event).forEach((name) => this.emitCognitiveServices(name, event[name]));
           const errorMessage = canceled && canceled.errorDetails;
           if (/Permission\sdenied/u.test(errorMessage || "")) {
-            finalEvent = {
-              error: "not-allowed",
-              type: "error"
-            };
+            finalEvent = new SpeechRecognitionErrorEvent("error", { error: "not-allowed" });
             break;
           }
           if (!loop) {
@@ -501,23 +606,14 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                 this.dispatchEvent(new SpeechRecognitionEvent("audiostart"));
                 this.dispatchEvent(new SpeechRecognitionEvent("audioend"));
               }
-              finalEvent = {
-                error: "network",
-                type: "error"
-              };
+              finalEvent = new SpeechRecognitionErrorEvent("error", { error: "network" });
             } else {
-              finalEvent = {
-                error: "unknown",
-                type: "error"
-              };
+              finalEvent = new SpeechRecognitionErrorEvent("error", { error: "unknown" });
             }
             break;
           } else if (abort || stop) {
             if (abort) {
-              finalEvent = {
-                error: "aborted",
-                type: "error"
-              };
+              finalEvent = new SpeechRecognitionErrorEvent("error", { error: "aborted" });
               stopping = "abort";
             } else {
               pause();
@@ -541,10 +637,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
           } else if (stopping !== "abort") {
             if (recognized && recognized.result && recognized.result.reason === ResultReason2.NoMatch) {
               if (!this.continuous || stopping === "stop") {
-                finalEvent = {
-                  results: [],
-                  type: "result"
-                };
+                finalEvent = new SpeechRecognitionEvent("result", { results: finalizedResults });
                 recognizer.stopContinuousRecognitionAsync && await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
                 break;
               }
@@ -562,7 +655,7 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                 speechStarted = true;
               }
               if (recognized) {
-                const result = cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(recognized.result, {
+                const result = cognitiveServiceEventResultToWebSpeechRecognitionResult_default(recognized.result, {
                   maxAlternatives: this.maxAlternatives,
                   textNormalization
                 });
@@ -571,35 +664,34 @@ function createSpeechRecognitionPonyfillFromRecognizer({
                   finalizedResults = [...finalizedResults, result];
                   this.continuous && this.dispatchEvent(
                     new SpeechRecognitionEvent("result", {
-                      results: finalizedResults
+                      results: new SpeechRecognitionResultList(finalizedResults)
                     })
                   );
                 }
                 if (this.continuous && recognizable) {
-                  finalEvent = null;
+                  finalEvent = void 0;
                 } else {
-                  finalEvent = {
-                    results: finalizedResults,
-                    type: "result"
-                  };
+                  finalEvent = new SpeechRecognitionEvent("result", {
+                    results: new SpeechRecognitionResultList(finalizedResults)
+                  });
                 }
                 if ((!this.continuous || stopping === "stop") && recognizer.stopContinuousRecognitionAsync) {
                   await cognitiveServicesAsyncToPromise(recognizer.stopContinuousRecognitionAsync.bind(recognizer))();
                 }
                 if (looseEvents && finalEvent && recognizable) {
-                  this.dispatchEvent(new SpeechRecognitionEvent(finalEvent.type, finalEvent));
-                  finalEvent = null;
+                  this.dispatchEvent(finalEvent);
+                  finalEvent = void 0;
                 }
               } else if (recognizing) {
                 this.interimResults && this.dispatchEvent(
                   new SpeechRecognitionEvent("result", {
-                    results: [
+                    results: new SpeechRecognitionResultList([
                       ...finalizedResults,
-                      cognitiveServiceEventResultToWebSpeechRecognitionResultList_default(recognizing.result, {
+                      cognitiveServiceEventResultToWebSpeechRecognitionResult_default(recognizing.result, {
                         maxAlternatives: this.maxAlternatives,
                         textNormalization
                       })
-                    ]
+                    ])
                   })
                 );
               }
@@ -617,16 +709,9 @@ function createSpeechRecognitionPonyfillFromRecognizer({
         }
         if (finalEvent) {
           if (finalEvent.type === "result" && !finalEvent.results.length) {
-            finalEvent = {
-              error: "no-speech",
-              type: "error"
-            };
-          }
-          if (finalEvent.type === "error") {
-            this.dispatchEvent(new ErrorEvent("error", finalEvent));
-          } else {
-            this.dispatchEvent(new SpeechRecognitionEvent(finalEvent.type, finalEvent));
+            finalEvent = new SpeechRecognitionErrorEvent("error", { error: "no-speech" });
           }
+          this.dispatchEvent(finalEvent);
         }
         this.dispatchEvent(new SpeechRecognitionEvent("end"));
         detachAudioConfigEvent();
@@ -698,7 +783,7 @@ var createSpeechRecognitionPonyfill_default = (options) => {
 var SpeechToText_default = createSpeechRecognitionPonyfill_default;
 
 // src/SpeechServices/TextToSpeech/createSpeechSynthesisPonyfill.js
-import { EventTarget as EventTarget3, getEventAttributeValue as getEventAttributeValue3, setEventAttributeValue as setEventAttributeValue3 } from "event-target-shim";
+import { EventTarget as EventTarget3, getEventAttributeValue as getEventAttributeValue2, setEventAttributeValue as setEventAttributeValue2 } from "event-target-shim";
 import { onErrorResumeNext } from "on-error-resume-next/async";
 
 // src/SpeechServices/TextToSpeech/AudioContextQueue.js
@@ -783,7 +868,7 @@ var SpeechSynthesisEvent = class extends Event2 {
 
 // src/SpeechServices/TextToSpeech/SpeechSynthesisUtterance.js
 import { EventAsPromise } from "event-as-promise";
-import { EventTarget as EventTarget2, getEventAttributeValue as getEventAttributeValue2, setEventAttributeValue as setEventAttributeValue2 } from "event-target-shim";
+import { EventTarget as EventTarget2, getEventAttributeValue, setEventAttributeValue } from "event-target-shim";
 
 // src/SpeechServices/TextToSpeech/fetchSpeechData.js
 import { decode } from "base64-arraybuffer";
@@ -922,46 +1007,46 @@ var SpeechSynthesisUtterance = class extends EventTarget2 {
     this._lang = value;
   }
   get onboundary() {
-    return getEventAttributeValue2(this, "boundary");
+    return getEventAttributeValue(this, "boundary");
   }
   set onboundary(value) {
-    setEventAttributeValue2(this, "boundary", value);
+    setEventAttributeValue(this, "boundary", value);
   }
   get onend() {
-    return getEventAttributeValue2(this, "end");
+    return getEventAttributeValue(this, "end");
   }
   set onend(value) {
-    setEventAttributeValue2(this, "end", value);
+    setEventAttributeValue(this, "end", value);
   }
   get onerror() {
-    return getEventAttributeValue2(this, "error");
+    return getEventAttributeValue(this, "error");
   }
   set onerror(value) {
-    setEventAttributeValue2(this, "error", value);
+    setEventAttributeValue(this, "error", value);
   }
   get onmark() {
-    return getEventAttributeValue2(this, "mark");
+    return getEventAttributeValue(this, "mark");
   }
   set onmark(value) {
-    setEventAttributeValue2(this, "mark", value);
+    setEventAttributeValue(this, "mark", value);
   }
   get onpause() {
-    return getEventAttributeValue2(this, "pause");
+    return getEventAttributeValue(this, "pause");
   }
   set onpause(value) {
-    setEventAttributeValue2(this, "pause", value);
+    setEventAttributeValue(this, "pause", value);
   }
   get onresume() {
-    return getEventAttributeValue2(this, "resume");
+    return getEventAttributeValue(this, "resume");
   }
   set onresume(value) {
-    setEventAttributeValue2(this, "resume", value);
+    setEventAttributeValue(this, "resume", value);
   }
   get onstart() {
-    return getEventAttributeValue2(this, "start");
+    return getEventAttributeValue(this, "start");
   }
   set onstart(value) {
-    setEventAttributeValue2(this, "start", value);
+    setEventAttributeValue(this, "start", value);
   }
   get pitch() {
     return this._pitch;
@@ -1126,10 +1211,10 @@ var createSpeechSynthesisPonyfill_default = (options) => {
       return EMPTY_ARRAY;
     }
     get onvoiceschanged() {
-      return getEventAttributeValue3(this, "voiceschanged");
+      return getEventAttributeValue2(this, "voiceschanged");
     }
     set onvoiceschanged(value) {
-      setEventAttributeValue3(this, "voiceschanged", value);
+      setEventAttributeValue2(this, "voiceschanged", value);
     }
     pause() {
       this.queue.pause();
@@ -1224,7 +1309,7 @@ function createSpeechServicesPonyfill(options = {}, ...args) {
 }
 var meta = document.createElement("meta");
 meta.setAttribute("name", "web-speech-cognitive-services");
-meta.setAttribute("content", `version=${"8.0.0-main.428d2a8"}`);
+meta.setAttribute("content", `version=${"8.0.0-main.5903868"}`);
 document.head.appendChild(meta);
 export {
   SpeechToText_default as createSpeechRecognitionPonyfill,