botframework-webchat 4.13.0 → 4.15.0

package/lib/speech/CustomAudioInputStream.js

@@ -0,0 +1,441 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _microsoftCognitiveservicesSpeechSdk = require("microsoft-cognitiveservices-speech-sdk");
+
+var _Exports = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common/Exports");
+
+var _AudioStreamFormat = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/src/sdk/Audio/AudioStreamFormat");
+
+var _Exports2 = require("microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common.speech/Exports");
+
+var _botframeworkWebchatCore = require("botframework-webchat-core");
+
+var _uuid = require("uuid");
+
+var _pDeferEs = _interopRequireDefault(require("p-defer-es5"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var SYMBOL_DEVICE_INFO_DEFERRED = Symbol('deviceInfoDeferred');
+var SYMBOL_EVENTS = Symbol('events');
+var SYMBOL_FORMAT_DEFERRED = Symbol('formatDeferred');
+var 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().
+
+var CustomAudioInputStream = /*#__PURE__*/function (_AudioInputStream) {
+  (0, _inherits2.default)(CustomAudioInputStream, _AudioInputStream);
+
+  var _super = _createSuper(CustomAudioInputStream);
+
+  function CustomAudioInputStream() {
+    var _this;
+
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, CustomAudioInputStream);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_DEVICE_INFO_DEFERRED, void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_EVENTS, void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_FORMAT_DEFERRED, void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_OPTIONS, void 0);
+    var normalizedOptions = {
+      debug: options.debug || false,
+      id: options.id || (0, _uuid.v4)().replace(/\x2D/g, '')
+    }; // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+
+    _this[SYMBOL_DEVICE_INFO_DEFERRED] = (0, _pDeferEs.default)(); // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+
+    _this[SYMBOL_EVENTS] = new _Exports.EventSource(); // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+
+    _this[SYMBOL_FORMAT_DEFERRED] = (0, _pDeferEs.default)(); // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+
+    _this[SYMBOL_OPTIONS] = normalizedOptions;
+    return _this;
+  }
+
+  (0, _createClass2.default)(CustomAudioInputStream, [{
+    key: "events",
+    get:
+    /** 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.
+    // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+    function get() {
+      // False alarm: indexer is a constant of type Symbol.
+      // eslint-disable-next-line security/detect-object-injection
+      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.
+    // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+
+  }, {
+    key: "format",
+    get: function get() {
+      this.debug('Getting "format".'); // False alarm: indexer is a constant of type Symbol.
+      // eslint-disable-next-line security/detect-object-injection
+
+      return this[SYMBOL_FORMAT_DEFERRED].promise;
+    }
+    /** Gets the ID of this audio stream. */
+
+  }, {
+    key: "id",
+    value: function id() {
+      // False alarm: indexer is a constant of type Symbol.
+      // eslint-disable-next-line security/detect-object-injection
+      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".
+
+  }, {
+    key: "onEvent",
+    value: function onEvent(event) {
+      // False alarm: indexer is a constant of type Symbol.
+      // eslint-disable-next-line security/detect-object-injection
+      this[SYMBOL_EVENTS].onEvent(event);
+
+      _Exports.Events.instance.onEvent(event);
+    }
+    /** Emits an `AudioSourceInitializingEvent`. */
+
+  }, {
+    key: "emitInitializing",
+    value: function emitInitializing() {
+      this.debug('Emitting "AudioSourceInitializingEvent".');
+      this.onEvent(new _Exports.AudioSourceInitializingEvent(this.id()));
+    }
+    /** Emits an `AudioSourceReadyEvent`. */
+
+  }, {
+    key: "emitReady",
+    value: function emitReady() {
+      this.debug('Emitting "AudioSourceReadyEvent".');
+      this.onEvent(new _Exports.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.
+
+  }, {
+    key: "emitError",
+    value: function emitError(error) {
+      this.debug('Emitting "AudioSourceErrorEvent".', {
+        error: error
+      }); // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+
+      this.onEvent(new _Exports.AudioSourceErrorEvent(this.id(), error.message));
+    }
+    /** Emits an `AudioStreamNodeAttachingEvent`. */
+
+  }, {
+    key: "emitNodeAttaching",
+    value: function emitNodeAttaching(audioNodeId) {
+      this.debug("Emitting \"AudioStreamNodeAttachingEvent\" for node \"".concat(audioNodeId, "\"."));
+      this.onEvent(new _Exports.AudioStreamNodeAttachingEvent(this.id(), audioNodeId));
+    }
+    /** Emits an `AudioStreamNodeAttachedEvent`. */
+
+  }, {
+    key: "emitNodeAttached",
+    value: function emitNodeAttached(audioNodeId) {
+      this.debug("Emitting \"AudioStreamNodeAttachedEvent\" for node \"".concat(audioNodeId, "\"."));
+      this.onEvent(new _Exports.AudioStreamNodeAttachedEvent(this.id(), audioNodeId));
+    }
+    /** Emits an `AudioStreamNodeErrorEvent`. */
+
+  }, {
+    key: "emitNodeError",
+    value: function emitNodeError(audioNodeId, error) {
+      this.debug("Emitting \"AudioStreamNodeErrorEvent\" for node \"".concat(audioNodeId, "\"."), {
+        error: error
+      }); // Speech SDK quirks: "error" is a string, instead of object of type "Error".
+
+      this.onEvent(new _Exports.AudioStreamNodeErrorEvent(this.id(), audioNodeId, error.message));
+    }
+    /** Emits an `AudioStreamNodeDetachedEvent`. */
+
+  }, {
+    key: "emitNodeDetached",
+    value: function emitNodeDetached(audioNodeId) {
+      this.debug('Emitting "AudioStreamNodeDetachedEvent".');
+      this.onEvent(new _Exports.AudioStreamNodeDetachedEvent(this.id(), audioNodeId));
+    }
+    /** Emits an `AudioSourceOffEvent`. */
+
+  }, {
+    key: "emitOff",
+    value: function emitOff() {
+      this.debug('Emitting "AudioSourceOffEvent".');
+      this.onEvent(new _Exports.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.
+
+  }, {
+    key: "close",
+    value: function close() {
+      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.
+
+  }, {
+    key: "turnOn",
+    value: function turnOn() {
+      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.
+
+  }, {
+    key: "detach",
+    value: function detach() {
+      this.debug('Callback for "detach".');
+      throw new Error('Not implemented');
+    }
+    /** Log the message to console if `debug` is set to `true`. */
+
+  }, {
+    key: "debug",
+    value: function debug(message) {
+      var _console;
+
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      // ESLint: For debugging, will only log when "debug" is set to "true".
+      // False alarm: indexer is a constant of type Symbol.
+      // eslint-disable-next-line no-console, security/detect-object-injection
+      this[SYMBOL_OPTIONS].debug && (_console = console).info.apply(_console, ["CustomAudioInputStream: ".concat(message)].concat(args));
+    }
+    /** Implements this function. When called, it should start recording and return an `IAudioStreamNode`. */
+
+  }, {
+    key: "attach",
+    value:
+    /** Attaches the device by returning an audio node. */
+    function attach(audioNodeId) {
+      var _this2 = this;
+
+      this.debug("Callback for \"attach\" with \"".concat(audioNodeId, "\"."));
+      this.emitNodeAttaching(audioNodeId);
+      return Promise.resolve().then( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var _yield$_this2$perform, audioStreamNode, deviceInfo, format;
+
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _this2.emitInitializing();
+
+                _context2.prev = 1;
+                _context2.next = 4;
+                return _this2.performAttach(audioNodeId);
+
+              case 4:
+                _yield$_this2$perform = _context2.sent;
+                audioStreamNode = _yield$_this2$perform.audioStreamNode;
+                deviceInfo = _yield$_this2$perform.deviceInfo;
+                format = _yield$_this2$perform.format;
+
+                // 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.
+                // False alarm: indexer is a constant of type Symbol.
+                // eslint-disable-next-line security/detect-object-injection
+                _this2[SYMBOL_DEVICE_INFO_DEFERRED].resolve(deviceInfo); // False alarm: indexer is a constant of type Symbol.
+                // eslint-disable-next-line security/detect-object-injection
+
+
+                _this2[SYMBOL_FORMAT_DEFERRED].resolve(new _AudioStreamFormat.AudioStreamFormatImpl(format.samplesPerSec, format.bitsPerSample, format.channels));
+
+                _this2.emitReady();
+
+                _this2.emitNodeAttached(audioNodeId);
+
+                return _context2.abrupt("return", {
+                  detach: function () {
+                    var _detach = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+                      return _regenerator.default.wrap(function _callee$(_context) {
+                        while (1) {
+                          switch (_context.prev = _context.next) {
+                            case 0:
+                              _this2.debug("Detaching audio node \"".concat(audioNodeId, "\"."));
+
+                              _context.next = 3;
+                              return audioStreamNode.detach();
+
+                            case 3:
+                              // Speech SDK quirks: Since "turnOff" is not called in Direct Line Speech, we will emit event "source off" here instead.
+                              _this2.emitOff();
+
+                              _this2.emitNodeDetached(audioNodeId);
+
+                            case 5:
+                            case "end":
+                              return _context.stop();
+                          }
+                        }
+                      }, _callee);
+                    }));
+
+                    function detach() {
+                      return _detach.apply(this, arguments);
+                    }
+
+                    return detach;
+                  }(),
+                  id: function id() {
+                    return audioStreamNode.id();
+                  },
+                  read: function read() {
+                    _this2.debug('Reading');
+
+                    return audioStreamNode.read();
+                  }
+                });
+
+              case 15:
+                _context2.prev = 15;
+                _context2.t0 = _context2["catch"](1);
+
+                _this2.emitNodeError(audioNodeId, _context2.t0);
+
+                throw _context2.t0;
+
+              case 19:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, null, [[1, 15]]);
+      })));
+    }
+    /**
+     * 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
+
+  }, {
+    key: "performTurnOff",
+    value: function performTurnOff() {
+      // 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.
+
+  }, {
+    key: "turnOff",
+    value: function () {
+      var _turnOff = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                this.debug("Callback for \"turnOff\".");
+                _context3.next = 3;
+                return this.performTurnOff();
+
+              case 3:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function turnOff() {
+        return _turnOff.apply(this, arguments);
+      }
+
+      return turnOff;
+    }()
+    /** Gets the device information. */
+    // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.
+    // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)
+
+  }, {
+    key: "deviceInfo",
+    get: function get() {
+      this.debug("Getting \"deviceInfo\"."); // False alarm: indexer is a constant of type Symbol.
+      // eslint-disable-next-line security/detect-object-injection
+
+      return Promise.all([this[SYMBOL_DEVICE_INFO_DEFERRED].promise, this[SYMBOL_FORMAT_DEFERRED].promise]).then(function (_ref2) {
+        var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
+            _ref3$ = _ref3[0],
+            connectivity = _ref3$.connectivity,
+            manufacturer = _ref3$.manufacturer,
+            model = _ref3$.model,
+            type = _ref3$.type,
+            _ref3$2 = _ref3[1],
+            bitsPerSample = _ref3$2.bitsPerSample,
+            channels = _ref3$2.channels,
+            samplesPerSec = _ref3$2.samplesPerSec;
+
+        return {
+          bitspersample: bitsPerSample,
+          channelcount: channels,
+          connectivity: typeof connectivity === 'string' && !(0, _botframeworkWebchatCore.isForbiddenPropertyName)(connectivity) ? // Mitigated through denylisting.
+          // eslint-disable-next-line security/detect-object-injection
+          _Exports2.connectivity[connectivity] : connectivity || _Exports2.connectivity.Unknown,
+          manufacturer: manufacturer || '',
+          model: model || '',
+          samplerate: samplesPerSec,
+          // Mitigated through denylisting.
+          // eslint-disable-next-line security/detect-object-injection
+          type: typeof type === 'string' && !(0, _botframeworkWebchatCore.isForbiddenPropertyName)(type) ? _Exports2.type[type] : type || _Exports2.type.Unknown
+        };
+      });
+    }
+  }]);
+  return CustomAudioInputStream;
+}(_microsoftCognitiveservicesSpeechSdk.AudioInputStream);
+
+var _default = CustomAudioInputStream;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/speech/CustomAudioInputStream.ts"],"names":["SYMBOL_DEVICE_INFO_DEFERRED","Symbol","SYMBOL_EVENTS","SYMBOL_FORMAT_DEFERRED","SYMBOL_OPTIONS","CustomAudioInputStream","options","normalizedOptions","debug","id","replace","EventSource","promise","event","onEvent","Events","instance","AudioSourceInitializingEvent","AudioSourceReadyEvent","error","AudioSourceErrorEvent","message","audioNodeId","AudioStreamNodeAttachingEvent","AudioStreamNodeAttachedEvent","AudioStreamNodeErrorEvent","AudioStreamNodeDetachedEvent","AudioSourceOffEvent","Error","args","console","info","emitNodeAttaching","Promise","resolve","then","emitInitializing","performAttach","audioStreamNode","deviceInfo","format","AudioStreamFormatImpl","samplesPerSec","bitsPerSample","channels","emitReady","emitNodeAttached","detach","emitOff","emitNodeDetached","read","emitNodeError","performTurnOff","all","connectivity","manufacturer","model","type","bitspersample","channelcount","Connectivity","Unknown","samplerate","Type","AudioInputStream"],"mappings":"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","sourceRoot":"bundle:///","sourcesContent":["import { AudioInputStream } from 'microsoft-cognitiveservices-speech-sdk';\n\nimport {\n  AudioSourceErrorEvent,\n  AudioSourceEvent,\n  AudioSourceInitializingEvent,\n  AudioSourceOffEvent,\n  AudioSourceReadyEvent,\n  AudioStreamNodeAttachedEvent,\n  AudioStreamNodeAttachingEvent,\n  AudioStreamNodeDetachedEvent,\n  AudioStreamNodeErrorEvent,\n  Events,\n  EventSource\n} from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common/Exports';\n\nimport { AudioStreamFormatImpl } from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/sdk/Audio/AudioStreamFormat';\n\nimport {\n  connectivity as Connectivity,\n  ISpeechConfigAudioDevice,\n  type as Type\n} from 'microsoft-cognitiveservices-speech-sdk/distrib/lib/src/common.speech/Exports';\n\nimport { isForbiddenPropertyName } from 'botframework-webchat-core';\nimport { v4 } from 'uuid';\nimport createDeferred, { DeferredPromise } from 'p-defer-es5';\n\ntype AudioStreamNode = {\n  detach: () => Promise<void>;\n  id: () => string;\n  read: () => Promise<StreamChunk<ArrayBuffer>>;\n};\n\ntype DeviceInfo = {\n  connectivity?: Connectivity | 'Bluetooth' | 'Wired' | 'WiFi' | 'Cellular' | 'InBuilt' | 'Unknown';\n  manufacturer?: string;\n  model?: string;\n  type?:\n    | Type\n    | 'Phone'\n    | 'Speaker'\n    | 'Car'\n    | 'Headset'\n    | 'Thermostat'\n    | 'Microphones'\n    | 'Deskphone'\n    | 'RemoteControl'\n    | 'Unknown'\n    | 'File'\n    | 'Stream';\n};\n\ntype Format = {\n  bitsPerSample: number;\n  channels: number;\n  samplesPerSec: number;\n};\n\ntype NormalizedOptions = Required<Omit<Options, 'debug'>> & {\n  debug: boolean;\n};\n\ntype Options = {\n  debug?: true;\n  id?: string;\n};\n\ntype StreamChunk<T> = {\n  isEnd: boolean;\n  buffer: T;\n  timeReceived: number;\n};\n\nconst SYMBOL_DEVICE_INFO_DEFERRED = Symbol('deviceInfoDeferred');\nconst SYMBOL_EVENTS = Symbol('events');\nconst SYMBOL_FORMAT_DEFERRED = Symbol('formatDeferred');\nconst SYMBOL_OPTIONS = Symbol('options');\n\n// Speech SDK quirks: Only 2 lifecycle functions are actually used.\n//                    They are: attach() and turnOff().\n//                    Others are not used, including: blob(), close(), detach(), turnOn().\nabstract class CustomAudioInputStream extends AudioInputStream {\n  constructor(options: Options = {}) {\n    super();\n\n    const normalizedOptions: NormalizedOptions = {\n      debug: options.debug || false,\n      id: options.id || v4().replace(/-/gu, '')\n    };\n\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    this[SYMBOL_DEVICE_INFO_DEFERRED] = createDeferred<DeviceInfo>();\n\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    this[SYMBOL_EVENTS] = new EventSource<AudioSourceEvent>();\n\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    this[SYMBOL_FORMAT_DEFERRED] = createDeferred<AudioStreamFormatImpl>();\n\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    this[SYMBOL_OPTIONS] = normalizedOptions;\n  }\n\n  [SYMBOL_DEVICE_INFO_DEFERRED]: DeferredPromise<DeviceInfo>;\n  [SYMBOL_EVENTS]: EventSource<AudioSourceEvent>;\n  [SYMBOL_FORMAT_DEFERRED]: DeferredPromise<AudioStreamFormatImpl>;\n  [SYMBOL_OPTIONS]: NormalizedOptions;\n\n  /** Gets the event source for listening to events. */\n  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.\n  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)\n  get events(): EventSource<AudioSourceEvent> {\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    return this[SYMBOL_EVENTS];\n  }\n\n  /** Gets the format of the audio stream. */\n  // Speech SDK quirks: `AudioStreamFormatImpl` is internal implementation while `AudioStreamFormat` is public.\n  //                    It is weird to expose `AudioStreamFormatImpl` instead of `AudioStreamFormat`.\n  // Speech SDK quirks: It is weird to return a `Promise` in a property.\n  // Speech SDK quirks: In normal speech recognition, getter of \"format\" is called only after \"attach\".\n  //                    But in Direct Line Speech, it is called before \"attach\".\n  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.\n  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)\n  get format(): Promise<AudioStreamFormatImpl> {\n    this.debug('Getting \"format\".');\n\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    return this[SYMBOL_FORMAT_DEFERRED].promise;\n  }\n\n  /** Gets the ID of this audio stream. */\n  id(): string {\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    return this[SYMBOL_OPTIONS].id;\n  }\n\n  /** Emits an event. */\n  // Speech SDK quirks: In JavaScript, onXxx means \"listen to event XXX\".\n  //                    Instead, in Speech SDK, it means \"emit event XXX\".\n  protected onEvent(event: AudioSourceEvent): void {\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    this[SYMBOL_EVENTS].onEvent(event);\n    Events.instance.onEvent(event);\n  }\n\n  /** Emits an `AudioSourceInitializingEvent`. */\n  protected emitInitializing(): void {\n    this.debug('Emitting \"AudioSourceInitializingEvent\".');\n    this.onEvent(new AudioSourceInitializingEvent(this.id()));\n  }\n\n  /** Emits an `AudioSourceReadyEvent`. */\n  protected emitReady(): void {\n    this.debug('Emitting \"AudioSourceReadyEvent\".');\n    this.onEvent(new AudioSourceReadyEvent(this.id()));\n  }\n\n  /** Emits an `AudioSourceErrorEvent`. */\n  // 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.\n  //                    Instead, we only emit \"node error\" event.\n  protected emitError(error: Error): void {\n    this.debug('Emitting \"AudioSourceErrorEvent\".', { error });\n\n    // Speech SDK quirks: \"error\" is a string, instead of object of type \"Error\".\n    this.onEvent(new AudioSourceErrorEvent(this.id(), error.message));\n  }\n\n  /** Emits an `AudioStreamNodeAttachingEvent`. */\n  protected emitNodeAttaching(audioNodeId: string): void {\n    this.debug(`Emitting \"AudioStreamNodeAttachingEvent\" for node \"${audioNodeId}\".`);\n    this.onEvent(new AudioStreamNodeAttachingEvent(this.id(), audioNodeId));\n  }\n\n  /** Emits an `AudioStreamNodeAttachedEvent`. */\n  protected emitNodeAttached(audioNodeId: string): void {\n    this.debug(`Emitting \"AudioStreamNodeAttachedEvent\" for node \"${audioNodeId}\".`);\n    this.onEvent(new AudioStreamNodeAttachedEvent(this.id(), audioNodeId));\n  }\n\n  /** Emits an `AudioStreamNodeErrorEvent`. */\n  protected emitNodeError(audioNodeId: string, error: Error): void {\n    this.debug(`Emitting \"AudioStreamNodeErrorEvent\" for node \"${audioNodeId}\".`, { error });\n\n    // Speech SDK quirks: \"error\" is a string, instead of object of type \"Error\".\n    this.onEvent(new AudioStreamNodeErrorEvent(this.id(), audioNodeId, error.message));\n  }\n\n  /** Emits an `AudioStreamNodeDetachedEvent`. */\n  protected emitNodeDetached(audioNodeId: string): void {\n    this.debug('Emitting \"AudioStreamNodeDetachedEvent\".');\n    this.onEvent(new AudioStreamNodeDetachedEvent(this.id(), audioNodeId));\n  }\n\n  /** Emits an `AudioSourceOffEvent`. */\n  protected emitOff(): void {\n    this.debug('Emitting \"AudioSourceOffEvent\".');\n    this.onEvent(new AudioSourceOffEvent(this.id()));\n  }\n\n  // Speech SDK quirks: Although \"close\" is marked as abstract, it is never called in our observations.\n  // ESLint: Speech SDK requires this function, but we are not implementing it.\n  close(): void {\n    this.debug('Callback for \"close\".');\n\n    throw new Error('Not implemented');\n  }\n\n  // Speech SDK quirks: Although \"turnOn\" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.\n  turnOn(): void {\n    this.debug('Callback for \"turnOn\".');\n\n    throw new Error('Not implemented');\n  }\n\n  // Speech SDK quirks: Although \"detach\" is implemented in Speech SDK Push/PullAudioInputStream, it is never called in our observations.\n  detach(): void {\n    this.debug('Callback for \"detach\".');\n\n    throw new Error('Not implemented');\n  }\n\n  /** Log the message to console if `debug` is set to `true`. */\n  private debug(message, ...args) {\n    // ESLint: For debugging, will only log when \"debug\" is set to \"true\".\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line no-console, security/detect-object-injection\n    this[SYMBOL_OPTIONS].debug && console.info(`CustomAudioInputStream: ${message}`, ...args);\n  }\n\n  /** Implements this function. When called, it should start recording and return an `IAudioStreamNode`. */\n  protected abstract performAttach(audioNodeId: string): Promise<{\n    audioStreamNode: AudioStreamNode;\n    deviceInfo: DeviceInfo;\n    format: Format;\n  }>;\n\n  /** Attaches the device by returning an audio node. */\n  attach(audioNodeId: string): Promise<AudioStreamNode> {\n    this.debug(`Callback for \"attach\" with \"${audioNodeId}\".`);\n\n    this.emitNodeAttaching(audioNodeId);\n\n    return Promise.resolve().then<AudioStreamNode>(async () => {\n      this.emitInitializing();\n\n      try {\n        const { audioStreamNode, deviceInfo, format } = await this.performAttach(audioNodeId);\n\n        // Although only getter of \"format\" is called before \"attach\" (in Direct Line Speech),\n        // we are handling both \"deviceInfo\" and \"format\" in similar way for uniformity.\n\n        // False alarm: indexer is a constant of type Symbol.\n        // eslint-disable-next-line security/detect-object-injection\n        this[SYMBOL_DEVICE_INFO_DEFERRED].resolve(deviceInfo);\n\n        // False alarm: indexer is a constant of type Symbol.\n        // eslint-disable-next-line security/detect-object-injection\n        this[SYMBOL_FORMAT_DEFERRED].resolve(\n          new AudioStreamFormatImpl(format.samplesPerSec, format.bitsPerSample, format.channels)\n        );\n\n        this.emitReady();\n        this.emitNodeAttached(audioNodeId);\n\n        return {\n          detach: async () => {\n            this.debug(`Detaching audio node \"${audioNodeId}\".`);\n\n            await audioStreamNode.detach();\n\n            // Speech SDK quirks: Since \"turnOff\" is not called in Direct Line Speech, we will emit event \"source off\" here instead.\n            this.emitOff();\n            this.emitNodeDetached(audioNodeId);\n          },\n          id: () => audioStreamNode.id(),\n          read: () => {\n            this.debug('Reading');\n\n            return audioStreamNode.read();\n          }\n        };\n      } catch (error) {\n        this.emitNodeError(audioNodeId, error);\n\n        throw error;\n      }\n    });\n  }\n\n  /**\n   * Implements this function. When called, it should stop recording. This is called before the `IAudioStreamNode.detach` function.\n   *\n   * Note: when using with Direct Line Speech, this function is never called.\n   */\n\n  // ESLint: We are not implementing this function because it is not called by Direct Line Speech.\n  // eslint-disable-next-line class-methods-use-this\n  protected performTurnOff(): Promise<void> {\n    // ESLint: \"return\" is required by TypeScript\n    // eslint-disable-next-line no-useless-return\n    return;\n  }\n\n  /** Turn off the audio device. This is called before detaching from the graph. */\n  // Speech SDK quirks: It is confused to have both \"turnOff\" and \"detach\". \"turnOff\" is called before \"detach\".\n  //                    Why don't we put all logics at \"detach\"?\n  // Speech SDK quirks: Direct Line Speech never call \"turnOff\". \"Source off\" event need to be emitted during \"detach\" instead.\n  //                    Also, custom implementation should be done at \"detach\" instead, such as ending and closing output streams.\n  async turnOff(): Promise<void> {\n    this.debug(`Callback for \"turnOff\".`);\n\n    await this.performTurnOff();\n  }\n\n  /** Gets the device information. */\n  // ESLint: This code will only works in browsers other than IE11. Only works in ES5 is okay.\n  // @ts-ignore Accessors are only available when targeting ECMAScript 5 and higher.ts(1056)\n  get deviceInfo(): Promise<ISpeechConfigAudioDevice> {\n    this.debug(`Getting \"deviceInfo\".`);\n\n    // False alarm: indexer is a constant of type Symbol.\n    // eslint-disable-next-line security/detect-object-injection\n    return Promise.all([this[SYMBOL_DEVICE_INFO_DEFERRED].promise, this[SYMBOL_FORMAT_DEFERRED].promise]).then(\n      ([{ connectivity, manufacturer, model, type }, { bitsPerSample, channels, samplesPerSec }]) => ({\n        bitspersample: bitsPerSample,\n        channelcount: channels,\n        connectivity:\n          typeof connectivity === 'string' && !isForbiddenPropertyName(connectivity)\n            ? // Mitigated through denylisting.\n              // eslint-disable-next-line security/detect-object-injection\n              Connectivity[connectivity]\n            : connectivity || Connectivity.Unknown,\n        manufacturer: manufacturer || '',\n        model: model || '',\n        samplerate: samplesPerSec,\n        // Mitigated through denylisting.\n        // eslint-disable-next-line security/detect-object-injection\n        type: typeof type === 'string' && !isForbiddenPropertyName(type) ? Type[type] : type || Type.Unknown\n      })\n    );\n  }\n}\n\nexport default CustomAudioInputStream;\n\nexport type { AudioStreamNode, DeviceInfo, Format, Options };\n"]}

package/lib/speech/bytesPerSample.d.ts

@@ -0,0 +1,2 @@
+export default function bytesPerSample(settings: MediaTrackSettings): number;
+//# sourceMappingURL=bytesPerSample.d.ts.map

package/lib/speech/bytesPerSample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytesPerSample.d.ts","sourceRoot":"","sources":["../../src/speech/bytesPerSample.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,QAAQ,EAAE,kBAAkB,UAGlE"}

package/lib/speech/bytesPerSample.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = bytesPerSample;
+
+function bytesPerSample(settings) {
+  // eslint-disable-next-line no-magic-numbers
+  return (settings.sampleSize >> 3) * settings.channelCount * settings.sampleRate;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcGVlY2gvYnl0ZXNQZXJTYW1wbGUudHMiXSwibmFtZXMiOlsiYnl0ZXNQZXJTYW1wbGUiLCJzZXR0aW5ncyIsInNhbXBsZVNpemUiLCJjaGFubmVsQ291bnQiLCJzYW1wbGVSYXRlIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBQWUsU0FBU0EsY0FBVCxDQUF3QkMsUUFBeEIsRUFBc0Q7QUFDbkU7QUFDQSxTQUFPLENBQUVBLFFBQVEsQ0FBQ0MsVUFBVixJQUFtQyxDQUFwQyxJQUEwQ0QsUUFBUSxDQUFDRSxZQUFuRCxHQUE4RUYsUUFBUSxDQUFDRyxVQUE5RjtBQUNEIiwic291cmNlUm9vdCI6ImJ1bmRsZTovLy8iLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBieXRlc1BlclNhbXBsZShzZXR0aW5nczogTWVkaWFUcmFja1NldHRpbmdzKSB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1tYWdpYy1udW1iZXJzXG4gIHJldHVybiAoKHNldHRpbmdzLnNhbXBsZVNpemUgYXMgbnVtYmVyKSA+PiAzKSAqIChzZXR0aW5ncy5jaGFubmVsQ291bnQgYXMgbnVtYmVyKSAqIChzZXR0aW5ncy5zYW1wbGVSYXRlIGFzIG51bWJlcik7XG59XG4iXX0=

package/lib/speech/createAudioConfig.d.ts

@@ -0,0 +1,23 @@
+import { AudioConfig } from 'microsoft-cognitiveservices-speech-sdk';
+import { AudioStreamNode, DeviceInfo, Format } from './CustomAudioInputStream';
+declare type AttachFunction = (audioNodeId: string) => Promise<{
+    audioStreamNode: AudioStreamNode;
+    deviceInfo: DeviceInfo;
+    format: Format;
+}>;
+declare type TurnOffFunction = () => Promise<void>;
+declare type CreateAudioConfigOptions = {
+    /** Callback function for attaching the device by returning an audio node. */
+    attach: AttachFunction;
+    /** `true` to enable diagnostic information, otherwise, `false`. */
+    debug?: true;
+    /**
+     * Callback function for turning off the device before detaching its node from an audio graph.
+     *
+     * Note: this is not called for Direct Line Speech.
+     */
+    turnOff?: TurnOffFunction;
+};
+export default function createAudioConfig(options: CreateAudioConfigOptions): AudioConfig;
+export {};
+//# sourceMappingURL=createAudioConfig.d.ts.map

package/lib/speech/createAudioConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAudioConfig.d.ts","sourceRoot":"","sources":["../../src/speech/createAudioConfig.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAErE,OAA+B,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAEvG,aAAK,cAAc,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACrD,eAAe,EAAE,eAAe,CAAC;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAEH,aAAK,eAAe,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAK3C,aAAK,wBAAwB,GAAG;IAC9B,6EAA6E;IAC7E,MAAM,EAAE,cAAc,CAAC;IAEvB,mEAAmE;IACnE,KAAK,CAAC,EAAE,IAAI,CAAC;IAEb;;;;OAIG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B,CAAC;AA2CF,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,eAE1E"}

package/lib/speech/createAudioConfig.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createAudioConfig;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _microsoftCognitiveservicesSpeechSdk = require("microsoft-cognitiveservices-speech-sdk");
+
+var _CustomAudioInputStream = _interopRequireDefault(require("./CustomAudioInputStream"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var SYMBOL_ATTACH = Symbol('attach');
+var SYMBOL_TURN_OFF = Symbol('turnOff');
+
+var CreateAudioConfigAudioInputStream = /*#__PURE__*/function (_CustomAudioInputStre) {
+  (0, _inherits2.default)(CreateAudioConfigAudioInputStream, _CustomAudioInputStre);
+
+  var _super = _createSuper(CreateAudioConfigAudioInputStream);
+
+  function CreateAudioConfigAudioInputStream(_ref) {
+    var _this;
+
+    var attach = _ref.attach,
+        debug = _ref.debug,
+        turnOff = _ref.turnOff;
+    (0, _classCallCheck2.default)(this, CreateAudioConfigAudioInputStream);
+
+    if (!attach || typeof attach !== 'function') {
+      throw new Error('"attach" must be a function.');
+    }
+
+    if (turnOff && typeof turnOff !== 'function') {
+      throw new Error('"turnOff", if defined, must be a function.');
+    }
+
+    _this = _super.call(this, {
+      debug: debug
+    }); // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_ATTACH, void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), SYMBOL_TURN_OFF, void 0);
+    _this[SYMBOL_ATTACH] = attach; // False alarm: indexer is a constant of type Symbol.
+    // eslint-disable-next-line security/detect-object-injection
+
+    _this[SYMBOL_TURN_OFF] = turnOff;
+    return _this;
+  }
+
+  (0, _createClass2.default)(CreateAudioConfigAudioInputStream, [{
+    key: "performAttach",
+    value: function performAttach(audioNodeId) {
+      // False alarm: indexer is a constant of type Symbol.
+      // eslint-disable-next-line security/detect-object-injection
+      return this[SYMBOL_ATTACH](audioNodeId);
+    }
+  }, {
+    key: "performTurnOff",
+    value: function performTurnOff() {
+      var turnOff = this[SYMBOL_TURN_OFF];
+      return turnOff && turnOff();
+    }
+  }]);
+  return CreateAudioConfigAudioInputStream;
+}(_CustomAudioInputStream.default);
+
+function createAudioConfig(options) {
+  return _microsoftCognitiveservicesSpeechSdk.AudioConfig.fromStreamInput(new CreateAudioConfigAudioInputStream(options));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/speech/createAudioContext.d.ts

@@ -0,0 +1,3 @@
+/** Creates an AudioContext object. */
+export default function createAudioContext(): AudioContext;
+//# sourceMappingURL=createAudioContext.d.ts.map

package/lib/speech/createAudioContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAudioContext.d.ts","sourceRoot":"","sources":["../../src/speech/createAudioContext.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,MAAM,CAAC,OAAO,UAAU,kBAAkB,IAAI,YAAY,CAczD"}