botframework-webchat 4.13.0 → 4.14.2

package/src/createDirectLineSpeechAdapters.ts

@@ -0,0 +1,84 @@
+import { AudioConfig } from 'microsoft-cognitiveservices-speech-sdk';
+import { createAdapters } from 'botframework-directlinespeech-sdk';
+import { DirectLineJSBotConnection } from 'botframework-webchat-core';
+import { WebSpeechPonyfill } from 'botframework-webchat-api';
+
+import CognitiveServicesAudioOutputFormat from './types/CognitiveServicesAudioOutputFormat';
+import CognitiveServicesCredentials from './types/CognitiveServicesCredentials';
+import CognitiveServicesTextNormalization from './types/CognitiveServicesTextNormalization';
+import createMicrophoneAudioConfigAndAudioContext from './speech/createMicrophoneAudioConfigAndAudioContext';
+
+const DEFAULT_LANGUAGE = 'en-US';
+
+// TODO: When using DLSpeech via bundle, we will add our own MicrophoneAudioConfig.
+export default function createDirectLineSpeechAdapters({
+  audioConfig,
+  audioContext,
+  audioInputDeviceId,
+  enableInternalHTTPSupport,
+  enableTelemetry,
+  fetchCredentials,
+  speechRecognitionEndpointId,
+  speechRecognitionLanguage = window?.navigator?.language || DEFAULT_LANGUAGE,
+  speechSynthesisDeploymentId,
+  speechSynthesisOutputFormat,
+  textNormalization,
+  userID,
+  username
+}: {
+  audioConfig?: AudioConfig;
+  audioContext?: AudioContext;
+  audioInputDeviceId?: string;
+  enableInternalHTTPSupport?: true;
+  enableTelemetry?: true;
+  fetchCredentials: CognitiveServicesCredentials;
+  speechRecognitionEndpointId?: string;
+  speechRecognitionLanguage?: string;
+  speechSynthesisDeploymentId?: string;
+  speechSynthesisOutputFormat?: CognitiveServicesAudioOutputFormat;
+  textNormalization?: CognitiveServicesTextNormalization;
+  userID?: string;
+  username?: string;
+}): {
+  directLine: DirectLineJSBotConnection;
+  webSpeechPonyfill: WebSpeechPonyfill;
+} {
+  if (audioConfig) {
+    audioInputDeviceId &&
+      console.warn(
+        'botframework-webchat: "audioConfig" and "audioInputDeviceId" cannot be set at the same time; ignoring "audioInputDeviceId".'
+      );
+
+    audioContext &&
+      console.warn(
+        'botframework-webchat: "audioConfig" and "audioContext" cannot be set at the same time; ignoring "audioContext" for speech recognition.'
+      );
+  } else if (!window.navigator.mediaDevices) {
+    // If the browser does not support or allow microphone access, we will continue to create Direct Line Speech adapter without custom "audioConfig" and "audioContext".
+    // In Direct Line Speech SDK, it will disable speech functionality, only leaving text chat available via the protocol.
+    console.warn(
+      'botframework-webchat: Your browser does not support or allow microphone access or the page is not loaded via HTTPS or localhost. Speech is disabled for Direct Line Speech. However, you may pass a custom "audioConfig" to enable speech in this environment.'
+    );
+  } else {
+    ({ audioConfig, audioContext } = createMicrophoneAudioConfigAndAudioContext({
+      audioContext,
+      audioInputDeviceId,
+      enableTelemetry
+    }));
+  }
+
+  return createAdapters({
+    audioConfig,
+    audioContext,
+    enableInternalHTTPSupport,
+    enableTelemetry,
+    fetchCredentials,
+    speechRecognitionEndpointId,
+    speechRecognitionLanguage,
+    speechSynthesisDeploymentId,
+    speechSynthesisOutputFormat,
+    textNormalization,
+    userID,
+    username
+  });
+}

package/src/createFullStyleSet.ts

@@ -1,13 +1,13 @@
 import { createStyleSet } from 'botframework-webchat-component';
-import { StyleOptions } from 'botframework-webchat-api';
 
 import createAdaptiveCardsStyleSet from './adaptiveCards/Styles/createAdaptiveCardsStyleSet';
+import FullBundleStyleOptions from './types/FullBundleStyleOptions';
 
 // TODO: [P4] We should add a notice for people who want to use "styleSet" instead of "styleOptions".
 //       "styleSet" is actually CSS stylesheet and it is based on the DOM tree.
 //       DOM tree may change from time to time, thus, maintaining "styleSet" becomes a constant effort.
 
-export default function createFullStyleSet(options: StyleOptions) {
+export default function createFullStyleSet(options: FullBundleStyleOptions) {
   return {
     ...createStyleSet(options),
     ...createAdaptiveCardsStyleSet(options)

package/src/fullBundleDefaultStyleOptions.ts

@@ -1,11 +1,11 @@
 import { defaultStyleOptions } from 'botframework-webchat-api';
 import adaptiveCardsDefaultStyleOptions from './adaptiveCards/defaultStyleOptions';
 
-import FullBundleStyleOptions from './FullBundleStyleOptions';
+import FullBundleStyleOptions from './types/FullBundleStyleOptions';
 
-const FULL_BUNDLE_DEFAULT_STYLE_OPTIONS: Required<FullBundleStyleOptions> = {
+const fullBundleDefaultStyleOptions: Required<FullBundleStyleOptions> = {
   ...defaultStyleOptions,
   ...adaptiveCardsDefaultStyleOptions
 };
 
-export default FULL_BUNDLE_DEFAULT_STYLE_OPTIONS;
+export default fullBundleDefaultStyleOptions;

package/src/hooks/useStyleOptions.ts

@@ -0,0 +1,9 @@
+import { hooks } from 'botframework-webchat-component';
+
+import { StrictFullBundleStyleOptions } from '../types/FullBundleStyleOptions';
+
+export default function useStyleOptions(): [StrictFullBundleStyleOptions] {
+  const [styleOptions] = hooks.useStyleOptions();
+
+  return [styleOptions as StrictFullBundleStyleOptions];
+}

package/src/index-es5.ts

@@ -1,5 +1,3 @@
-// IMPORTANT: To export anything from this file, add it to index-es5.tsx, which is the .d.ts for this file.
-
 /* eslint dot-notation: ["error", { "allowPattern": "^WebChat$" }] */
 // window['WebChat'] is required for TypeScript
 

package/src/index-minimal.ts

@@ -1,9 +1,8 @@
-// IMPORTANT: To export anything from this file, add it to index-minimal.tsx, which is the .d.ts for this file.
-
 /* eslint dot-notation: ["error", { "allowPattern": "^WebChat$" }] */
 // window['WebChat'] is required for TypeScript
 
 import { Constants, createStore, createStoreWithDevTools, version } from 'botframework-webchat-core';
+import { StrictStyleOptions, StyleOptions } from 'botframework-webchat-api';
 
 import ReactWebChat, {
   Components,
@@ -55,6 +54,8 @@ export {
   version
 };
 
+export type { StyleOptions, StrictStyleOptions };
+
 // Until we have a development-specific bundle, we are not shipping createStoreWithDevTools in bundle.
 window['WebChat'] = {
   ...window['WebChat'],

package/src/index.ts

@@ -1,5 +1,3 @@
-// IMPORTANT: To export anything from this file, add it to index.tsx, which is the .d.ts for this file.
-
 /* eslint dot-notation: ["error", { "allowPattern": "^WebChat$" }] */
 // window['WebChat'] is required for TypeScript
 
@@ -18,6 +16,7 @@ import createDirectLineSpeechAdapters from './createDirectLineSpeechAdapters';
 import createStyleSet from './createFullStyleSet';
 import defaultCreateDirectLine from './createDirectLine';
 import defaultCreateDirectLineAppServiceExtension from './createDirectLineAppServiceExtension';
+import FullBundleStyleOptions, { StrictFullBundleStyleOptions } from './types/FullBundleStyleOptions';
 import FullComposer from './FullComposer';
 import HeroCardContent from './adaptiveCards/Attachment/HeroCardContent';
 import OAuthCardContent from './adaptiveCards/Attachment/OAuthCardContent';
@@ -28,12 +27,13 @@ import SignInCardContent from './adaptiveCards/Attachment/SignInCardContent';
 import ThumbnailCardContent from './adaptiveCards/Attachment/ThumbnailCardContent';
 import useAdaptiveCardsHostConfig from './adaptiveCards/hooks/useAdaptiveCardsHostConfig';
 import useAdaptiveCardsPackage from './adaptiveCards/hooks/useAdaptiveCardsPackage';
+import useStyleOptions from './hooks/useStyleOptions';
 import VideoCardContent from './adaptiveCards/Attachment/VideoCardContent';
 
 const renderWebChat = coreRenderWebChat.bind(null, ReactWebChat);
 
-export const createDirectLine = options => {
-  options.botAgent &&
+export const createDirectLine = (options: Omit<Parameters<typeof defaultCreateDirectLine>[0], 'botAgent'>) => {
+  (options as any).botAgent &&
     console.warn(
       'Web Chat: Developers are not currently allowed to set botAgent. See https://github.com/microsoft/BotFramework-WebChat/issues/2119 for more details.'
     );
@@ -41,8 +41,10 @@ export const createDirectLine = options => {
   return defaultCreateDirectLine({ ...options, botAgent: `WebChat/${version} (Full)` });
 };
 
-export const createDirectLineAppServiceExtension = options => {
-  options.botAgent &&
+export const createDirectLineAppServiceExtension = (
+  options: Omit<Parameters<typeof defaultCreateDirectLineAppServiceExtension>[0], 'botAgent'>
+) => {
+  (options as any).botAgent &&
     console.warn(
       'Web Chat: Developers are not currently allowed to set botAgent. See https://github.com/microsoft/BotFramework-WebChat/issues/2119 for more details.'
     );
@@ -53,14 +55,14 @@ export const createDirectLineAppServiceExtension = options => {
 const patchedHooks = {
   ...hooks,
   useAdaptiveCardsHostConfig,
-  useAdaptiveCardsPackage
+  useAdaptiveCardsPackage,
+  useStyleOptions
 };
 
-const Components = {
-  ...MinimalComponents,
+const AdditionalComponents = {
   AdaptiveCardContent,
-  AudioCardContent,
   AnimationCardContent,
+  AudioCardContent,
   Composer: FullComposer,
   HeroCardContent,
   OAuthCardContent,
@@ -70,6 +72,14 @@ const Components = {
   VideoCardContent
 };
 
+const Components: typeof MinimalComponents & typeof AdditionalComponents = {
+  ...MinimalComponents,
+  ...AdditionalComponents
+};
+
+type StyleOptions = FullBundleStyleOptions;
+type StrictStyleOptions = StrictFullBundleStyleOptions;
+
 export default ReactWebChat;
 
 export {
@@ -84,6 +94,8 @@ export {
   renderWebChat
 };
 
+export type { StyleOptions, StrictStyleOptions };
+
 window['WebChat'] = {
   ...window['WebChat'],
   Components,

package/src/{renderMarkdown.js → renderMarkdown.ts}

@@ -57,7 +57,11 @@ const TRANSPARENT_GIF = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAA
 // This is used for parsing Markdown for external links.
 const internalMarkdownIt = new MarkdownIt();
 
-export default function render(markdown, { markdownRespectCRLF }, { externalLinkAlt = '' } = {}) {
+export default function render(
+  markdown: string,
+  { markdownRespectCRLF }: { markdownRespectCRLF: boolean },
+  { externalLinkAlt = '' }: { externalLinkAlt?: string } = {}
+): string {
   if (markdownRespectCRLF) {
     markdown = markdown.replace(/\n\r|\r\n/gu, carriageReturn => (carriageReturn === '\n\r' ? '\r\n' : '\n\r'));
   }
@@ -93,5 +97,8 @@ export default function render(markdown, { markdownRespectCRLF }, { externalLink
     })
     .render(markdown);
 
+  // The signature from "sanitize-html" module is not correct.
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
   return sanitizeHTML(html, SANITIZE_HTML_OPTIONS);
 }

package/src/renderWebChat.tsx

@@ -0,0 +1,6 @@
+import React, { ComponentType } from 'react';
+import ReactDOM from 'react-dom';
+
+export default function renderWebChat(ReactWebChat: ComponentType<any>, props: any, element: HTMLElement): void {
+  ReactDOM.render(<ReactWebChat {...props} />, element);
+}

package/src/speech/CustomAudioInputStream.ts

@@ -0,0 +1,325 @@
+import { AudioInputStream } from 'microsoft-cognitiveservices-speech-sdk';
+
+import {
+  AudioSourceErrorEvent,
+  AudioSourceEvent,
+  AudioSourceInitializingEvent,
+  AudioSourceOffEvent,
+  AudioSourceReadyEvent,
+  AudioStreamNodeAttachedEvent,
+  AudioStreamNodeAttachingEvent,
+  AudioStreamNodeDetachedEvent,
+  AudioStreamNodeErrorEvent,
+  Events,
+  EventSource
+} from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common/Exports';
+
+import { AudioStreamFormatImpl } from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/sdk/Audio/AudioStreamFormat';
+
+import {
+  connectivity as Connectivity,
+  ISpeechConfigAudioDevice,
+  type as Type
+} from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common.speech/Exports';
+
+import { v4 } from 'uuid';
+import createDeferred, { DeferredPromise } from 'p-defer-es5';
+
+type AudioStreamNode = {
+  detach: () => Promise<void>;
+  id: () => string;
+  read: () => Promise<StreamChunk<ArrayBuffer>>;
+};
+
+type DeviceInfo = {
+  connectivity?: Connectivity | 'Bluetooth' | 'Wired' | 'WiFi' | 'Cellular' | 'InBuilt' | 'Unknown';
+  manufacturer?: string;
+  model?: string;
+  type?:
+    | Type
+    | 'Phone'
+    | 'Speaker'
+    | 'Car'
+    | 'Headset'
+    | 'Thermostat'
+    | 'Microphones'
+    | 'Deskphone'
+    | 'RemoteControl'
+    | 'Unknown'
+    | 'File'
+    | 'Stream';
+};
+
+type Format = {
+  bitsPerSample: number;
+  channels: number;
+  samplesPerSec: number;
+};
+
+type NormalizedOptions = Required<Omit<Options, 'debug'>> & {
+  debug: boolean;
+};
+
+type Options = {
+  debug?: true;
+  id?: string;
+};
+
+type StreamChunk<T> = {
+  isEnd: boolean;
+  buffer: T;
+  timeReceived: number;
+};
+
+const SYMBOL_DEVICE_INFO_DEFERRED = Symbol('deviceInfoDeferred');
+const SYMBOL_EVENTS = Symbol('events');
+const SYMBOL_FORMAT_DEFERRED = Symbol('formatDeferred');
+const SYMBOL_OPTIONS = Symbol('options');
+
+// Speech SDK quirks: Only 2 lifecycle functions are actually used.
+//                    They are: attach() and turnOff().
+//                    Others are not used, including: blob(), close(), detach(), turnOn().
+abstract class CustomAudioInputStream extends AudioInputStream {
+  constructor(options: Options = {}) {
+    super();
+
+    const normalizedOptions: NormalizedOptions = {
+      debug: options.debug || false,
+      id: options.id || v4().replace(/-/gu, '')
+    };
+
+    this[SYMBOL_DEVICE_INFO_DEFERRED] = createDeferred<DeviceInfo>();
+    this[SYMBOL_EVENTS] = new EventSource<AudioSourceEvent>();
+    this[SYMBOL_FORMAT_DEFERRED] = createDeferred<AudioStreamFormatImpl>();
+    this[SYMBOL_OPTIONS] = normalizedOptions;
+  }
+
+  [SYMBOL_DEVICE_INFO_DEFERRED]: DeferredPromise<DeviceInfo>;
+  [SYMBOL_EVENTS]: EventSource<AudioSourceEvent>;
+  [SYMBOL_FORMAT_DEFERRED]: DeferredPromise<AudioStreamFormatImpl>;
+  [SYMBOL_OPTIONS]: NormalizedOptions;
+
+  /** Gets the event source for listening to events. */
+  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+  get events(): EventSource<AudioSourceEvent> {
+    return this[SYMBOL_EVENTS];
+  }
+
+  /** Gets the format of the audio stream. */
+  // Speech SDK quirks: `AudioStreamFormatImpl` is internal implementation while `AudioStreamFormat` is public.
+  //                    It is weird to expose `AudioStreamFormatImpl` instead of `AudioStreamFormat`.
+  // Speech SDK quirks: It is weird to return a `Promise` in a property.
+  // Speech SDK quirks: In normal speech recognition, getter of "format" is called only after "attach".
+  //                    But in Direct Line Speech, it is called before "attach".
+  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+  get format(): Promise<AudioStreamFormatImpl> {
+    this.debug('Getting "format".');
+
+    return this[SYMBOL_FORMAT_DEFERRED].promise;
+  }
+
+  /** Gets the ID of this audio stream. */
+  id(): string {
+    return this[SYMBOL_OPTIONS].id;
+  }
+
+  /** Emits an event. */
+  // Speech SDK quirks: In JavaScript, onXxx means "listen to event XXX".
+  //                    Instead, in Speech SDK, it means "emit event XXX".
+  protected onEvent(event: AudioSourceEvent): void {
+    this[SYMBOL_EVENTS].onEvent(event);
+    Events.instance.onEvent(event);
+  }
+
+  /** Emits an `AudioSourceInitializingEvent`. */
+  protected emitInitializing(): void {
+    this.debug('Emitting "AudioSourceInitializingEvent".');
+    this.onEvent(new AudioSourceInitializingEvent(this.id()));
+  }
+
+  /** Emits an `AudioSourceReadyEvent`. */
+  protected emitReady(): void {
+    this.debug('Emitting "AudioSourceReadyEvent".');
+    this.onEvent(new AudioSourceReadyEvent(this.id()));
+  }
+
+  /** Emits an `AudioSourceErrorEvent`. */
+  // Speech SDK quirks: Since "turnOn" is never called and "turnOff" does not work in Direct Line Speech, the "source error" event is not emitted at all.
+  //                    Instead, we only emit "node error" event.
+  protected emitError(error: Error): void {
+    this.debug('Emitting "AudioSourceErrorEvent".', { error });
+
+    // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+    this.onEvent(new AudioSourceErrorEvent(this.id(), error.message));
+  }
+
+  /** Emits an `AudioStreamNodeAttachingEvent`. */
+  protected emitNodeAttaching(audioNodeId: string): void {
+    this.debug(`Emitting "AudioStreamNodeAttachingEvent" for node "${audioNodeId}".`);
+    this.onEvent(new AudioStreamNodeAttachingEvent(this.id(), audioNodeId));
+  }
+
+  /** Emits an `AudioStreamNodeAttachedEvent`. */
+  protected emitNodeAttached(audioNodeId: string): void {
+    this.debug(`Emitting "AudioStreamNodeAttachedEvent" for node "${audioNodeId}".`);
+    this.onEvent(new AudioStreamNodeAttachedEvent(this.id(), audioNodeId));
+  }
+
+  /** Emits an `AudioStreamNodeErrorEvent`. */
+  protected emitNodeError(audioNodeId: string, error: Error): void {
+    this.debug(`Emitting "AudioStreamNodeErrorEvent" for node "${audioNodeId}".`, { error });
+
+    // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+    this.onEvent(new AudioStreamNodeErrorEvent(this.id(), audioNodeId, error.message));
+  }
+
+  /** Emits an `AudioStreamNodeDetachedEvent`. */
+  protected emitNodeDetached(audioNodeId: string): void {
+    this.debug('Emitting "AudioStreamNodeDetachedEvent".');
+    this.onEvent(new AudioStreamNodeDetachedEvent(this.id(), audioNodeId));
+  }
+
+  /** Emits an `AudioSourceOffEvent`. */
+  protected emitOff(): void {
+    this.debug('Emitting "AudioSourceOffEvent".');
+    this.onEvent(new AudioSourceOffEvent(this.id()));
+  }
+
+  // Speech SDK quirks: Although "close" is marked as abstract, it is never called in our observations.
+  // ESLint: Speech SDK requires this function, but we are not implementing it.
+  // eslint-disable-next-line class-methods-use-this
+  close(): void {
+    this.debug('Callback for "close".');
+
+    throw new Error('Not implemented');
+  }
+
+  // Speech SDK quirks: Although "turnOn" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.
+  turnOn(): void {
+    this.debug('Callback for "turnOn".');
+
+    throw new Error('Not implemented');
+  }
+
+  // Speech SDK quirks: Although "detach" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.
+  detach(): void {
+    this.debug('Callback for "detach".');
+
+    throw new Error('Not implemented');
+  }
+
+  /** Log the message to console if `debug` is set to `true`. */
+  private debug(message, ...args) {
+    // ESLint: For debugging, will only log when "debug" is set to "true".
+    // eslint-disable-next-line no-console
+    this[SYMBOL_OPTIONS].debug && console.info(`CustomAudioInputStream: ${message}`, ...args);
+  }
+
+  /** Implements this function. When called, it should start recording and return an `IAudioStreamNode`. */
+  protected abstract performAttach(audioNodeId: string): Promise<{
+    audioStreamNode: AudioStreamNode;
+    deviceInfo: DeviceInfo;
+    format: Format;
+  }>;
+
+  /** Attaches the device by returning an audio node. */
+  attach(audioNodeId: string): Promise<AudioStreamNode> {
+    this.debug(`Callback for "attach" with "${audioNodeId}".`);
+
+    this.emitNodeAttaching(audioNodeId);
+
+    return Promise.resolve().then<AudioStreamNode>(async () => {
+      this.emitInitializing();
+
+      try {
+        const { audioStreamNode, deviceInfo, format } = await this.performAttach(audioNodeId);
+
+        // Although only getter of "format" is called before "attach" (in Direct Line Speech),
+        // we are handling both "deviceInfo" and "format" in similar way for uniformity.
+        this[SYMBOL_DEVICE_INFO_DEFERRED].resolve(deviceInfo);
+        this[SYMBOL_FORMAT_DEFERRED].resolve(
+          new AudioStreamFormatImpl(format.samplesPerSec, format.bitsPerSample, format.channels)
+        );
+
+        this.emitReady();
+        this.emitNodeAttached(audioNodeId);
+
+        return {
+          detach: async () => {
+            this.debug(`Detaching audio node "${audioNodeId}".`);
+
+            await audioStreamNode.detach();
+
+            // Speech SDK quirks: Since "turnOff" is not called in Direct Line Speech, we will emit event "source off" here instead.
+            this.emitOff();
+            this.emitNodeDetached(audioNodeId);
+          },
+          id: () => audioStreamNode.id(),
+          read: () => {
+            this.debug('Reading');
+
+            return audioStreamNode.read();
+          }
+        };
+      } catch (error) {
+        this.emitNodeError(audioNodeId, error);
+
+        throw error;
+      }
+    });
+  }
+
+  /**
+   * Implements this function. When called, it should stop recording. This is called before the `IAudioStreamNode.detach` function.
+   *
+   * Note: when using with Direct Line Speech, this function is never called.
+   */
+
+  // ESLint: We are not implementing this function because it is not called by Direct Line Speech.
+  // eslint-disable-next-line class-methods-use-this
+  protected performTurnOff(): Promise<void> {
+    // ESLint: "return" is required by TypeScript
+    // eslint-disable-next-line no-useless-return
+    return;
+  }
+
+  /** Turn off the audio device. This is called before detaching from the graph. */
+  // Speech SDK quirks: It is confused to have both "turnOff" and "detach". "turnOff" is called before "detach".
+  //                    Why don't we put all logics at "detach"?
+  // Speech SDK quirks: Direct Line Speech never call "turnOff". "Source off" event need to be emitted during "detach" instead.
+  //                    Also, custom implementation should be done at "detach" instead, such as ending and closing output streams.
+  async turnOff(): Promise<void> {
+    this.debug(`Callback for "turnOff".`);
+
+    await this.performTurnOff();
+  }
+
+  /** Gets the device information. */
+  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+  get deviceInfo(): Promise<ISpeechConfigAudioDevice> {
+    this.debug(`Getting "deviceInfo".`);
+
+    return Promise.all([this[SYMBOL_DEVICE_INFO_DEFERRED].promise, this[SYMBOL_FORMAT_DEFERRED].promise]).then(
+      ([{ connectivity, manufacturer, model, type }, { bitsPerSample, channels, samplesPerSec }]) => ({
+        bitspersample: bitsPerSample,
+        channelcount: channels,
+        connectivity:
+          typeof connectivity === 'string' ? Connectivity[connectivity] : connectivity || Connectivity.Unknown,
+        manufacturer: manufacturer || '',
+        model: model || '',
+        samplerate: samplesPerSec,
+        type: typeof type === 'string' ? Type[type] : type || Type.Unknown
+      })
+    );
+  }
+}
+
+export default CustomAudioInputStream;
+
+export type { AudioStreamNode, DeviceInfo, Format, Options };

package/src/speech/bytesPerSample.ts

@@ -0,0 +1,4 @@
+export default function bytesPerSample(settings: MediaTrackSettings) {
+  // eslint-disable-next-line no-magic-numbers
+  return ((settings.sampleSize as number) >> 3) * (settings.channelCount as number) * (settings.sampleRate as number);
+}

package/src/speech/createAudioConfig.spec.js

@@ -0,0 +1,23 @@
+/* eslint @typescript-eslint/no-empty-function: "off" */
+
+import createAudioConfig from './createAudioConfig';
+
+describe('Verify arguments', () => {
+  test('should not throw if only "attach" is supplied', () => {
+    expect(() => createAudioConfig({ attach: () => {} })).not.toThrow();
+  });
+
+  test('should not throw if both "attach" and "turnOff" are supplied', () => {
+    expect(() => createAudioConfig({ attach: () => {}, turnOff: () => {} })).not.toThrow();
+  });
+
+  test('should throw if "attach" is not supplied', () => {
+    expect(() => createAudioConfig({})).toThrow('"attach" must be a function.');
+  });
+
+  test('should throw if "turnOff" is not a function', () => {
+    expect(() => createAudioConfig({ attach: () => {}, turnOff: '123' })).toThrow(
+      '"turnOff", if defined, must be a function.'
+    );
+  });
+});