web-speech-cognitive-services 8.0.1-main.8743165 → 8.1.1-main.3d23aad

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

@@ -38,6 +38,12 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfill.ts
+var import_microsoft_cognitiveservices_speech_sdk = require("microsoft-cognitiveservices-speech-sdk");
+
+// src/SpeechServices/patchOptions.ts
+var import_valibot8 = require("valibot");
+
 // src/SpeechServices/resolveFunctionOrReturnValue.ts
 function isFunction(value) {
   return typeof value === "function";
@@ -46,97 +52,145 @@ function resolveFunctionOrReturnValue(fnOrValue) {
   return isFunction(fnOrValue) ? fnOrValue() : fnOrValue;
 }
 
+// src/SpeechServices/SpeechSDK.ts
+var import_microsoft_cognitiveservices_speech = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk");
+var SpeechSDK_default = {
+  AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
+  OutputFormat: import_microsoft_cognitiveservices_speech.OutputFormat,
+  ResultReason: import_microsoft_cognitiveservices_speech.ResultReason,
+  SpeechConfig: import_microsoft_cognitiveservices_speech.SpeechConfig,
+  SpeechRecognizer: import_microsoft_cognitiveservices_speech.SpeechRecognizer
+};
+
+// src/SpeechServices/SpeechToText/validation/credentialsSchema.ts
+var import_valibot = require("valibot");
+var credentialsSchema = (0, import_valibot.pipe)(
+  (0, import_valibot.intersect)([
+    (0, import_valibot.union)(
+      [
+        (0, import_valibot.object)({
+          authorizationToken: (0, import_valibot.string)(),
+          subscriptionKey: (0, import_valibot.optional)((0, import_valibot.undefined_)('"subscriptionKey" must be unset when "authorizationToken" is set.'))
+        }),
+        (0, import_valibot.object)({
+          authorizationToken: (0, import_valibot.optional)((0, import_valibot.undefined_)('"authorizationToken" must be unset when "subscriptionKey" is set.')),
+          subscriptionKey: (0, import_valibot.string)()
+        })
+      ],
+      'The object must either have either "authorizationToken" or "subscriptionKey" set, but not both.'
+    ),
+    (0, import_valibot.union)(
+      [
+        (0, import_valibot.object)({
+          customVoiceHostname: (0, import_valibot.optional)((0, import_valibot.undefined_)('"customVoiceHostname" must be unest when "region" is set.')),
+          region: (0, import_valibot.string)(),
+          speechRecognitionHostname: (0, import_valibot.optional)(
+            (0, import_valibot.undefined_)('"speechRecognitionHostname" must be unest when "region" is set.')
+          ),
+          speechSynthesisHostname: (0, import_valibot.optional)((0, import_valibot.undefined_)('"speechSynthesisHostname" must be unest when "region" is set.'))
+        }),
+        (0, import_valibot.object)({
+          customVoiceHostname: (0, import_valibot.optional)((0, import_valibot.union)([(0, import_valibot.string)(), (0, import_valibot.undefined_)()])),
+          region: (0, import_valibot.optional)((0, import_valibot.undefined_)('"region" must be unset when "*Hostname" is set.')),
+          speechRecognitionHostname: (0, import_valibot.string)(),
+          speechSynthesisHostname: (0, import_valibot.string)()
+        })
+      ],
+      'The object must either have either "region" or "*Hostname" set, but not both.'
+    )
+  ]),
+  (0, import_valibot.readonly)()
+);
+var credentialsSchema_default = credentialsSchema;
+
+// src/SpeechServices/SpeechToText/validation/enableTelemetrySchema.ts
+var import_valibot2 = require("valibot");
+var enableTelemetrySchema = (0, import_valibot2.optional)((0, import_valibot2.boolean)());
+var enableTelemetrySchema_default = enableTelemetrySchema;
+
+// src/SpeechServices/SpeechToText/validation/initialSilenceTimeoutSchema.ts
+var import_valibot3 = require("valibot");
+var initialSilenceTimeoutSchema = (0, import_valibot3.optional)((0, import_valibot3.pipe)((0, import_valibot3.number)(), (0, import_valibot3.minValue)(1), (0, import_valibot3.maxValue)(6e4)));
+var initialSilenceTimeoutSchema_default = initialSilenceTimeoutSchema;
+
+// src/SpeechServices/SpeechToText/validation/looseEventsSchema.ts
+var import_valibot4 = require("valibot");
+var looseEventsSchema = (0, import_valibot4.optional)((0, import_valibot4.boolean)(), false);
+var looseEventsSchema_default = looseEventsSchema;
+
+// src/SpeechServices/SpeechToText/validation/referenceGrammarsSchema.ts
+var import_valibot5 = require("valibot");
+var referenceGrammarsSchema = (0, import_valibot5.pipe)(
+  (0, import_valibot5.optional)((0, import_valibot5.array)((0, import_valibot5.string)()), []),
+  // any(),
+  // array(string()),
+  // transform<string[], readonly string[]>(value => (Object.isFrozen(value) ? value : Object.freeze([...value])))
+  (0, import_valibot5.transform)((value) => Object.isFrozen(value) ? value : Object.freeze([...value]))
+);
+var referenceGrammarsSchema_default = referenceGrammarsSchema;
+
+// src/SpeechServices/SpeechToText/validation/speechRecognitionEndpointIdSchema.ts
+var import_valibot6 = require("valibot");
+var speechRecognitionEndpointIdSchema = (0, import_valibot6.optional)((0, import_valibot6.string)());
+var speechRecognitionEndpointIdSchema_default = speechRecognitionEndpointIdSchema;
+
+// src/SpeechServices/SpeechToText/validation/textNormalizationSchema.ts
+var import_valibot7 = require("valibot");
+var textNormalizationSchema = (0, import_valibot7.optional)(
+  (0, import_valibot7.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: (0, import_valibot8.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 = (0, import_valibot8.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: (0, import_valibot8.parse)(initialSilenceTimeoutSchema_default, initialSilenceTimeout),
+    looseEvents: (0, import_valibot8.parse)(looseEventsSchema_default, looseEvents),
+    referenceGrammars: (0, import_valibot8.parse)(referenceGrammarsSchema_default, referenceGrammars),
+    speechRecognitionEndpointId: (0, import_valibot8.parse)(speechRecognitionEndpointIdSchema_default, speechRecognitionEndpointId),
+    textNormalization: (0, import_valibot8.parse)(textNormalizationSchema_default, textNormalization)
   });
 }
 
-// src/SpeechServices/SpeechSDK.ts
-var import_microsoft_cognitiveservices_speech = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/microsoft.cognitiveservices.speech.sdk");
-var SpeechSDK_default = {
-  AudioConfig: import_microsoft_cognitiveservices_speech.AudioConfig,
-  OutputFormat: import_microsoft_cognitiveservices_speech.OutputFormat,
-  ResultReason: import_microsoft_cognitiveservices_speech.ResultReason,
-  SpeechConfig: import_microsoft_cognitiveservices_speech.SpeechConfig,
-  SpeechRecognizer: import_microsoft_cognitiveservices_speech.SpeechRecognizer
-};
+// src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfillFromRecognizer.ts
+var import_valibot9 = require("valibot");
 
 // ../../node_modules/p-defer/index.js
 function pDefer() {
@@ -191,16 +245,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];
         }
       });
     }
@@ -291,8 +345,8 @@ var import_AudioSourceEvents = require("microsoft-cognitiveservices-speech-sdk/d
 
 // 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
@@ -440,6 +494,7 @@ var SpeechRecognitionEvent = class extends Event {
 
 // src/SpeechServices/SpeechToText/createSpeechRecognitionPonyfillFromRecognizer.ts
 var { ResultReason: ResultReason2, SpeechRecognizer: SpeechRecognizer2 } = SpeechSDK_default;
+var enableTelemetrySchema2 = (0, import_valibot9.union)([(0, import_valibot9.boolean)(), (0, import_valibot9.undefined_)()]);
 function createSpeechRecognitionPonyfillFromRecognizer({
   createRecognizer,
   enableTelemetry,
@@ -447,7 +502,12 @@ function createSpeechRecognitionPonyfillFromRecognizer({
   referenceGrammars,
   textNormalization
 }) {
-  SpeechRecognizer2.enableTelemetry(enableTelemetry !== false);
+  createRecognizer = (0, import_valibot9.parse)((0, import_valibot9.function_)(), createRecognizer);
+  enableTelemetry = (0, import_valibot9.parse)(enableTelemetrySchema2, enableTelemetry);
+  looseEvents = (0, import_valibot9.parse)((0, import_valibot9.boolean)(), looseEvents);
+  referenceGrammars = (0, import_valibot9.parse)(referenceGrammarsSchema_default, referenceGrammars);
+  textNormalization = (0, import_valibot9.parse)(textNormalizationSchema_default, textNormalization);
+  typeof enableTelemetry !== "undefined" && SpeechRecognizer2.enableTelemetry(enableTelemetry);
   class SpeechRecognition extends EventTarget {
     #continuous = false;
     #eventListenerMap = new EventListenerMap(this);
@@ -817,18 +877,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(
@@ -839,7 +898,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);
@@ -855,6 +914,7 @@ function createSpeechRecognitionPonyfill(options) {
     }
     speechConfig.outputFormat = OutputFormat2.Detailed;
     speechConfig.speechRecognitionLanguage = lang || "en-US";
+    typeof initialSilenceTimeout === "number" && speechConfig.setProperty(import_microsoft_cognitiveservices_speech_sdk.PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "" + initialSilenceTimeout);
     return new SpeechRecognizer3(speechConfig, audioConfig);
   };
   return createSpeechRecognitionPonyfillFromRecognizer({
@@ -1396,7 +1456,7 @@ function createSpeechServicesPonyfill(options = {}) {
 }
 var meta = document.createElement("meta");
 meta.setAttribute("name", "web-speech-cognitive-services");
-meta.setAttribute("content", `version=${"8.0.1-main.8743165"}`);
+meta.setAttribute("content", `version=${"8.1.1-main.3d23aad"}`);
 document.head.appendChild(meta);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {