web-speech-cognitive-services 8.0.0 → 8.0.1-main.7b3a347

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

@@ -1,3 +1,9 @@
+// src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.ts
+import { PropertyId } from "microsoft-cognitiveservices-speech-sdk";
+
+// src/SpeechServices/patchOptions.ts
+import { parse } from "valibot";
+
 // src/SpeechServices/resolveFunctionOrReturnValue.ts
 function isFunction(value) {
   return typeof value === "function";
@@ -6,103 +12,151 @@ function resolveFunctionOrReturnValue(fnOrValue) {
   return isFunction(fnOrValue) ? fnOrValue() : fnOrValue;
 }
 
+// src/SpeechServices/SpeechSDK.ts
+import {
+  AudioConfig,
+  OutputFormat,
+  ResultReason,
+  SpeechConfig,
+  SpeechRecognizer
+} from "microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk";
+var SpeechSDK_default = {
+  AudioConfig,
+  OutputFormat,
+  ResultReason,
+  SpeechConfig,
+  SpeechRecognizer
+};
+
+// src/SpeechServices/SpeechToText/validation/credentialsSchema.ts
+import { intersect, object, optional, pipe, readonly, string, undefined_, union } from "valibot";
+var credentialsSchema = pipe(
+  intersect([
+    union(
+      [
+        object({
+          authorizationToken: string(),
+          subscriptionKey: optional(undefined_('"subscriptionKey" must be unset when "authorizationToken" is set.'))
+        }),
+        object({
+          authorizationToken: optional(undefined_('"authorizationToken" must be unset when "subscriptionKey" is set.')),
+          subscriptionKey: string()
+        })
+      ],
+      'The object must either have either "authorizationToken" or "subscriptionKey" set, but not both.'
+    ),
+    union(
+      [
+        object({
+          customVoiceHostname: optional(undefined_('"customVoiceHostname" must be unest when "region" is set.')),
+          region: string(),
+          speechRecognitionHostname: optional(
+            undefined_('"speechRecognitionHostname" must be unest when "region" is set.')
+          ),
+          speechSynthesisHostname: optional(undefined_('"speechSynthesisHostname" must be unest when "region" is set.'))
+        }),
+        object({
+          customVoiceHostname: optional(union([string(), undefined_()])),
+          region: optional(undefined_('"region" must be unset when "*Hostname" is set.')),
+          speechRecognitionHostname: string(),
+          speechSynthesisHostname: string()
+        })
+      ],
+      'The object must either have either "region" or "*Hostname" set, but not both.'
+    )
+  ]),
+  readonly()
+);
+var credentialsSchema_default = credentialsSchema;
+
+// src/SpeechServices/SpeechToText/validation/enableTelemetrySchema.ts
+import { boolean, optional as optional2 } from "valibot";
+var enableTelemetrySchema = optional2(boolean());
+var enableTelemetrySchema_default = enableTelemetrySchema;
+
+// src/SpeechServices/SpeechToText/validation/initialSilenceTimeoutSchema.ts
+import { maxValue, minValue, number, optional as optional3, pipe as pipe2 } from "valibot";
+var initialSilenceTimeoutSchema = optional3(pipe2(number(), minValue(1), maxValue(6e4)));
+var initialSilenceTimeoutSchema_default = initialSilenceTimeoutSchema;
+
+// src/SpeechServices/SpeechToText/validation/looseEventsSchema.ts
+import { boolean as boolean2, optional as optional4 } from "valibot";
+var looseEventsSchema = optional4(boolean2(), false);
+var looseEventsSchema_default = looseEventsSchema;
+
+// src/SpeechServices/SpeechToText/validation/referenceGrammarsSchema.ts
+import { array, optional as optional5, pipe as pipe3, string as string2, transform } from "valibot";
+var referenceGrammarsSchema = pipe3(
+  optional5(array(string2()), []),
+  // any(),
+  // array(string()),
+  // transform<string[], readonly string[]>(value => (Object.isFrozen(value) ? value : Object.freeze([...value])))
+  transform((value) => Object.isFrozen(value) ? value : Object.freeze([...value]))
+);
+var referenceGrammarsSchema_default = referenceGrammarsSchema;
+
+// src/SpeechServices/SpeechToText/validation/speechRecognitionEndpointIdSchema.ts
+import { optional as optional6, string as string3 } from "valibot";
+var speechRecognitionEndpointIdSchema = optional6(string3());
+var speechRecognitionEndpointIdSchema_default = speechRecognitionEndpointIdSchema;
+
+// src/SpeechServices/SpeechToText/validation/textNormalizationSchema.ts
+import { enum_, optional as optional7 } from "valibot";
+var textNormalizationSchema = optional7(
+  enum_({
+    display: "display",
+    itn: "itn",
+    lexical: "lexical",
+    maskeditn: "maskeditn"
+  }),
+  "display"
+);
+var textNormalizationSchema_default = textNormalizationSchema;
+
 // src/SpeechServices/patchOptions.ts
+var { AudioConfig: AudioConfig2 } = SpeechSDK_default;
 var shouldWarnOnSubscriptionKey = true;
 function patchOptions(init) {
   const {
     audioConfig,
-    authorizationToken,
+    credentials,
     enableTelemetry,
+    initialSilenceTimeout,
     looseEvent,
     referenceGrammars,
-    region = "westus",
     speechRecognitionEndpointId,
-    subscriptionKey,
     textNormalization
   } = init;
-  let { credentials, looseEvents } = init;
+  let { looseEvents } = init;
   if (typeof looseEvent !== "undefined") {
     console.warn('web-speech-cognitive-services: The option "looseEvent" should be named as "looseEvents".');
     looseEvents = looseEvent;
   }
-  if (!credentials) {
-    if (!authorizationToken && !subscriptionKey) {
-      throw new Error("web-speech-cognitive-services: Credentials must be specified.");
-    } else {
-      console.warn(
-        "web-speech-cognitive-services: We are deprecating authorizationToken, region, and subscriptionKey. Please use credentials instead. The deprecated option will be removed on or after 2020-11-14."
-      );
-      credentials = async () => typeof init.authorizationToken !== "undefined" ? { authorizationToken: await resolveFunctionOrReturnValue(init.authorizationToken), region } : { region, subscriptionKey: await resolveFunctionOrReturnValue(init.subscriptionKey) };
-    }
-  }
   return Object.freeze({
-    audioConfig,
-    enableTelemetry,
+    audioConfig: audioConfig || AudioConfig2.fromDefaultMicrophoneInput(),
+    // We set telemetry to true to honor the default telemetry settings of Speech SDK
+    // https://github.com/Microsoft/cognitive-services-speech-sdk-js#data--telemetry
+    enableTelemetry: parse(enableTelemetrySchema_default, enableTelemetry),
     fetchCredentials: async () => {
-      const {
-        authorizationToken: authorizationToken2,
-        customVoiceHostname,
-        region: region2,
-        speechRecognitionHostname,
-        speechSynthesisHostname,
-        subscriptionKey: subscriptionKey2
-      } = await resolveFunctionOrReturnValue(credentials);
-      if (!authorizationToken2 && !subscriptionKey2 || authorizationToken2 && subscriptionKey2) {
-        throw new Error(
-          'web-speech-cognitive-services: Either "authorizationToken" or "subscriptionKey" must be provided.'
-        );
-      } else if (!region2 && !(speechRecognitionHostname && speechSynthesisHostname)) {
-        throw new Error(
-          'web-speech-cognitive-services: Either "region" or "speechRecognitionHostname" and "speechSynthesisHostname" must be set.'
-        );
-      } else if (region2 && (customVoiceHostname || speechRecognitionHostname || speechSynthesisHostname)) {
-        throw new Error(
-          'web-speech-cognitive-services: Only either "region" or "customVoiceHostname", "speechRecognitionHostname" and "speechSynthesisHostname" can be set.'
-        );
-      } else if (authorizationToken2) {
-        if (typeof authorizationToken2 !== "string") {
-          throw new Error('web-speech-cognitive-services: "authorizationToken" must be a string.');
-        }
-      } else if (typeof subscriptionKey2 !== "string") {
-        throw new Error('web-speech-cognitive-services: "subscriptionKey" must be a string.');
-      }
-      if (shouldWarnOnSubscriptionKey && subscriptionKey2) {
+      const parsedCredentials = parse(credentialsSchema_default, await resolveFunctionOrReturnValue(credentials));
+      if (shouldWarnOnSubscriptionKey && parsedCredentials.subscriptionKey) {
         console.warn(
           "web-speech-cognitive-services: In production environment, subscription key should not be used, authorization token should be used instead."
         );
         shouldWarnOnSubscriptionKey = false;
       }
-      return {
-        ...typeof authorizationToken2 !== "undefined" ? { authorizationToken: authorizationToken2 } : { subscriptionKey: subscriptionKey2 },
-        ...typeof region2 !== "undefined" ? { region: region2 } : {
-          customVoiceHostname,
-          speechRecognitionHostname,
-          speechSynthesisHostname
-        }
-      };
+      return parsedCredentials;
     },
-    looseEvents: !!looseEvents,
-    referenceGrammars: referenceGrammars && Object.freeze([...referenceGrammars]),
-    speechRecognitionEndpointId,
-    textNormalization
+    initialSilenceTimeout: parse(initialSilenceTimeoutSchema_default, initialSilenceTimeout),
+    looseEvents: parse(looseEventsSchema_default, looseEvents),
+    referenceGrammars: parse(referenceGrammarsSchema_default, referenceGrammars),
+    speechRecognitionEndpointId: parse(speechRecognitionEndpointIdSchema_default, speechRecognitionEndpointId),
+    textNormalization: parse(textNormalizationSchema_default, textNormalization)
   });
 }
 
-// src/SpeechServices/SpeechSDK.ts
-import {
-  AudioConfig,
-  OutputFormat,
-  ResultReason,
-  SpeechConfig,
-  SpeechRecognizer
-} from "microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk";
-var SpeechSDK_default = {
-  AudioConfig,
-  OutputFormat,
-  ResultReason,
-  SpeechConfig,
-  SpeechRecognizer
-};
+// src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfillFromRecognizer.ts
+import { boolean as boolean3, function_, parse as parse2, undefined_ as undefined_2, union as union2 } from "valibot";
 
 // ../../node_modules/p-defer/index.js
 function pDefer() {
@@ -157,16 +211,16 @@ var SpeechRecognitionAlternative = class {
 
 // src/SpeechServices/SpeechToText/private/FakeArray.ts
 var FakeArray = class {
-  constructor(array) {
-    if (!array) {
+  constructor(array2) {
+    if (!array2) {
       throw new Error("array must be set.");
     }
-    this.#array = array;
-    for (const key in array) {
+    this.#array = array2;
+    for (const key in array2) {
       Object.defineProperty(this, key, {
         enumerable: true,
         get() {
-          return array[key];
+          return array2[key];
         }
       });
     }
@@ -257,8 +311,8 @@ import { AudioSourceEvent } from "microsoft-cognitiveservices-speech-sdk/distrib
 
 // src/SpeechServices/SpeechToText/private/averageAmplitude.ts
 function averageAmplitude(arrayBuffer) {
-  const array = Array.from(new Int16Array(arrayBuffer));
-  return array.reduce((averageAmplitude2, amplitude) => averageAmplitude2 + Math.abs(amplitude), 0) / array.length;
+  const array2 = Array.from(new Int16Array(arrayBuffer));
+  return array2.reduce((averageAmplitude2, amplitude) => averageAmplitude2 + Math.abs(amplitude), 0) / array2.length;
 }
 
 // src/SpeechServices/SpeechToText/private/prepareAudioConfig.ts
@@ -406,6 +460,7 @@ var SpeechRecognitionEvent = class extends Event {
 
 // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfillFromRecognizer.ts
 var { ResultReason: ResultReason2, SpeechRecognizer: SpeechRecognizer2 } = SpeechSDK_default;
+var enableTelemetrySchema2 = union2([boolean3(), undefined_2()]);
 function createSpeechRecognitionPonyfillFromRecognizer({
   createRecognizer,
   enableTelemetry,
@@ -413,7 +468,12 @@ function createSpeechRecognitionPonyfillFromRecognizer({
   referenceGrammars,
   textNormalization
 }) {
-  SpeechRecognizer2.enableTelemetry(enableTelemetry !== false);
+  createRecognizer = parse2(function_(), createRecognizer);
+  enableTelemetry = parse2(enableTelemetrySchema2, enableTelemetry);
+  looseEvents = parse2(boolean3(), looseEvents);
+  referenceGrammars = parse2(referenceGrammarsSchema_default, referenceGrammars);
+  textNormalization = parse2(textNormalizationSchema_default, textNormalization);
+  typeof enableTelemetry !== "undefined" && SpeechRecognizer2.enableTelemetry(enableTelemetry);
   class SpeechRecognition extends EventTarget {
     #continuous = false;
     #eventListenerMap = new EventListenerMap(this);
@@ -783,18 +843,17 @@ function createSpeechRecognitionPonyfillFromRecognizer({
 }
 
 // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.ts
-var { AudioConfig: AudioConfig2, OutputFormat: OutputFormat2, SpeechConfig: SpeechConfig2, SpeechRecognizer: SpeechRecognizer3 } = SpeechSDK_default;
+var { OutputFormat: OutputFormat2, SpeechConfig: SpeechConfig2, SpeechRecognizer: SpeechRecognizer3 } = SpeechSDK_default;
 function createSpeechRecognitionPonyfill(options) {
   const {
-    audioConfig = AudioConfig2.fromDefaultMicrophoneInput(),
-    // We set telemetry to true to honor the default telemetry settings of Speech SDK
-    // https://github.com/Microsoft/cognitive-services-speech-sdk-js#data--telemetry
-    enableTelemetry = true,
+    audioConfig,
+    enableTelemetry,
     fetchCredentials,
+    initialSilenceTimeout,
     looseEvents,
     referenceGrammars,
     speechRecognitionEndpointId,
-    textNormalization = "display"
+    textNormalization
   } = patchOptions(options);
   if (!audioConfig && (!window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia)) {
     throw new Error(
@@ -805,7 +864,7 @@ function createSpeechRecognitionPonyfill(options) {
     const credentials = await fetchCredentials();
     let speechConfig;
     if (typeof credentials.speechRecognitionHostname !== "undefined") {
-      const host = new URL("wss://hostname:443");
+      const host = new URL("wss://localhost:443");
       host.hostname = credentials.speechRecognitionHostname;
       if (credentials.authorizationToken) {
         speechConfig = SpeechConfig2.fromHost(host);
@@ -821,6 +880,7 @@ function createSpeechRecognitionPonyfill(options) {
     }
     speechConfig.outputFormat = OutputFormat2.Detailed;
     speechConfig.speechRecognitionLanguage = lang || "en-US";
+    typeof initialSilenceTimeout === "number" && speechConfig.setProperty(PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "" + initialSilenceTimeout);
     return new SpeechRecognizer3(speechConfig, audioConfig);
   };
   return createSpeechRecognitionPonyfillFromRecognizer({
@@ -1362,7 +1422,7 @@ function createSpeechServicesPonyfill(options = {}) {
 }
 var meta = document.createElement("meta");
 meta.setAttribute("name", "web-speech-cognitive-services");
-meta.setAttribute("content", `version=${"8.0.0"}`);
+meta.setAttribute("content", `version=${"8.0.1-main.7b3a347"}`);
 document.head.appendChild(meta);
 export {
   createSpeechRecognitionPonyfill,