@webex/media-helpers 3.0.0-bnr.4 → 3.0.0-next.1

package/README.md

@@ -21,6 +21,78 @@ npm install --save @webex/media-helpers
 
 ## Usage
 
+### Effects
+There are two effects included in this package:
+
+Virtual background (e.g., blur, image replacement, video replacement)
+Noise reduction (e.g., background noise removal)
+
+#### Virtual background
+The virtual background effect provides a virtual background for video calling. The virtual background may be an image, an mp4 video, or the user's background with blur applied.
+
+**Applying the effect**
+1. Create a new camera track instance by using LocalCameraTrack() method.
+2. Create a VirtualBackgroundEffect instance by passing appropriate constraints.
+3. Use addEffect() method on cameraTrack to apply effect on it.
+4. Enable the effect after adding it to cameraTrack using enable() method available on effect. Effect will be enabled on cameraTrack.
+
+```javascript
+import {LocalCameraTrack, VirtualBackgroundEffect} from '@webex/media-helpers';
+
+// Create a new video stream by a getting user's video media.
+const stream = await navigator.mediaDevices.getUserMedia({ video: { width, height } });
+
+const videoTrackFromLocalStream = stream.getVideoTracks()[0];
+
+const cameraTrack = new LocalCameraTrack(new MediaStream([videoTrackFromLocalStream]));
+
+// Create the effect.
+const effect = new VirtualBackgroundEffect({
+  authToken: '<encoded-string>',
+  mode: `BLUR`,
+  blurStrength: `STRONG`,
+  quality: `LOW`,
+});
+
+// add the effect on the input camera track.
+await cameraTrack.addEffect("background-blur", effect);
+
+//enable the effect once it is added to the track
+await effect.enable()
+```
+
+#### Noise reduction
+The noise reduction effect removes background noise from an audio stream to provide clear audio for calling.
+
+**Applying the effect**
+1. Create a new microphone track instance by using LocalMicrophoneTrack() method.
+2. Create a NoiseReductionEffect instance by passing appropriate constraints.
+3. Use addEffect() method on microphoneTrack to apply effect on it.
+4. Enable the effect after adding it to microphoneTrack using enable() method available on effect. Effect will be enabled on microphoneTrack.
+
+```javascript
+import {LocalMicrophoneTrack, NoiseReductionEffect} from '@webex/media-helpers';
+
+// Create a new audio stream by getting a user's audio media.
+const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+
+const audioTrackFromLocalStream = stream.getAudioTracks()[0];
+
+const microphoneTrack = new LocalMicrophoneTrack(new MediaStream([audioTrackFromLocalStream]));
+
+// Create the effect.
+const effect = new NoiseReductionEffect({
+  authToken: '<encoded-string>',
+  mode: 'WORKLET', // or 'LEGACY'
+});
+
+// add the effect on microphone track.
+await microphoneTrack.addEffect("background-noise-removal", effect);
+
+//enable the effect once it is added to the track
+await effect.enable()
+```
+
 ## Maintainers
 
 This package is maintained by [Cisco Webex for Developers](https://developer.webex.com/).

package/babel.config.json

@@ -0,0 +1,13 @@
+{
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "node": "current"
+          }
+        }
+      ],
+      "@babel/preset-typescript"
+    ],
+}

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+import { VideoDeviceConstraints } from '@webex/internal-media-core';
+export declare enum FacingMode {
+    user = "user",
+    environment = "environment"
+}
+export declare enum DisplaySurface {
+    browser = "browser",
+    monitor = "monitor",
+    window = "window"
+}
+export declare const PresetCameraConstraints: {
+    [key: string]: VideoDeviceConstraints;
+};

package/dist/constants.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PresetCameraConstraints = exports.FacingMode = exports.DisplaySurface = void 0;
+var FacingMode; // can be used later on when we add constraints in create display track
+exports.FacingMode = FacingMode;
+(function (FacingMode) {
+  FacingMode["user"] = "user";
+  FacingMode["environment"] = "environment";
+})(FacingMode || (exports.FacingMode = FacingMode = {}));
+var DisplaySurface;
+exports.DisplaySurface = DisplaySurface;
+(function (DisplaySurface) {
+  DisplaySurface["browser"] = "browser";
+  DisplaySurface["monitor"] = "monitor";
+  DisplaySurface["window"] = "window";
+})(DisplaySurface || (exports.DisplaySurface = DisplaySurface = {}));
+var PresetCameraConstraints = {
+  '1080p': {
+    frameRate: 30,
+    width: 1920,
+    height: 1080
+  },
+  '720p': {
+    frameRate: 30,
+    width: 1280,
+    height: 720
+  },
+  '480p': {
+    frameRate: 30,
+    width: 640,
+    height: 480
+  },
+  '360p': {
+    frameRate: 30,
+    width: 640,
+    height: 360
+  },
+  '240p': {
+    frameRate: 30,
+    width: 320,
+    height: 240
+  },
+  '180p': {
+    frameRate: 30,
+    width: 320,
+    height: 180
+  },
+  '120p': {
+    frameRate: 30,
+    width: 160,
+    height: 120
+  }
+};
+exports.PresetCameraConstraints = PresetCameraConstraints;
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FacingMode","exports","DisplaySurface","PresetCameraConstraints","frameRate","width","height"],"sources":["constants.ts"],"sourcesContent":["import {VideoDeviceConstraints} from '@webex/internal-media-core';\n\nexport enum FacingMode {\n  user = 'user',\n  environment = 'environment',\n}\n\n// can be used later on when we add constraints in create display track\nexport enum DisplaySurface {\n  browser = 'browser',\n  monitor = 'monitor',\n  window = 'window',\n}\n\nexport const PresetCameraConstraints: {[key: string]: VideoDeviceConstraints} = {\n  '1080p': {frameRate: 30, width: 1920, height: 1080},\n\n  '720p': {frameRate: 30, width: 1280, height: 720},\n\n  '480p': {frameRate: 30, width: 640, height: 480},\n\n  '360p': {frameRate: 30, width: 640, height: 360},\n\n  '240p': {frameRate: 30, width: 320, height: 240},\n\n  '180p': {frameRate: 30, width: 320, height: 180},\n\n  '120p': {frameRate: 30, width: 160, height: 120},\n};\n"],"mappings":";;;;;;;IAEYA,UAAU,EAKtB;AAAAC,OAAA,CAAAD,UAAA,GAAAA,UAAA;AAAA,WALYA,UAAU;EAAVA,UAAU;EAAVA,UAAU;AAAA,GAAVA,UAAU,KAAAC,OAAA,CAAAD,UAAA,GAAVA,UAAU;AAAA,IAMVE,cAAc;AAAAD,OAAA,CAAAC,cAAA,GAAAA,cAAA;AAAA,WAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;AAAA,GAAdA,cAAc,KAAAD,OAAA,CAAAC,cAAA,GAAdA,cAAc;AAMnB,IAAMC,uBAAgE,GAAG;EAC9E,OAAO,EAAE;IAACC,SAAS,EAAE,EAAE;IAAEC,KAAK,EAAE,IAAI;IAAEC,MAAM,EAAE;EAAI,CAAC;EAEnD,MAAM,EAAE;IAACF,SAAS,EAAE,EAAE;IAAEC,KAAK,EAAE,IAAI;IAAEC,MAAM,EAAE;EAAG,CAAC;EAEjD,MAAM,EAAE;IAACF,SAAS,EAAE,EAAE;IAAEC,KAAK,EAAE,GAAG;IAAEC,MAAM,EAAE;EAAG,CAAC;EAEhD,MAAM,EAAE;IAACF,SAAS,EAAE,EAAE;IAAEC,KAAK,EAAE,GAAG;IAAEC,MAAM,EAAE;EAAG,CAAC;EAEhD,MAAM,EAAE;IAACF,SAAS,EAAE,EAAE;IAAEC,KAAK,EAAE,GAAG;IAAEC,MAAM,EAAE;EAAG,CAAC;EAEhD,MAAM,EAAE;IAACF,SAAS,EAAE,EAAE;IAAEC,KAAK,EAAE,GAAG;IAAEC,MAAM,EAAE;EAAG,CAAC;EAEhD,MAAM,EAAE;IAACF,SAAS,EAAE,EAAE;IAAEC,KAAK,EAAE,GAAG;IAAEC,MAAM,EAAE;EAAG;AACjD,CAAC;AAACL,OAAA,CAAAE,uBAAA,GAAAA,uBAAA"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { getDevices, LocalStream, LocalDisplayStream, LocalSystemAudioStream, LocalStreamEventNames, StreamEventNames, type ServerMuteReason, LocalMicrophoneStreamEventNames, LocalCameraStreamEventNames, LocalMicrophoneStream, LocalCameraStream, createMicrophoneStream, createCameraStream, createDisplayStream, createDisplayStreamWithAudio, } from './webrtc-core';
+export { NoiseReductionEffect, VirtualBackgroundEffect } from '@webex/web-media-effects';
+export type { NoiseReductionEffectOptions, VirtualBackgroundEffectOptions, } from '@webex/web-media-effects';
+export { FacingMode, DisplaySurface, PresetCameraConstraints } from './constants';

package/dist/index.js

@@ -4,65 +4,121 @@ var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/defi
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-_Object$defineProperty(exports, "LocalCameraTrack", {
+_Object$defineProperty(exports, "DisplaySurface", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.LocalCameraTrack;
+    return _constants.DisplaySurface;
   }
 });
-_Object$defineProperty(exports, "LocalCameraTrackEvents", {
+_Object$defineProperty(exports, "FacingMode", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.LocalCameraTrackEvents;
+    return _constants.FacingMode;
   }
 });
-_Object$defineProperty(exports, "LocalDisplayTrack", {
+_Object$defineProperty(exports, "LocalCameraStream", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.LocalDisplayTrack;
+    return _webrtcCore.LocalCameraStream;
   }
 });
-_Object$defineProperty(exports, "LocalMicrophoneTrack", {
+_Object$defineProperty(exports, "LocalCameraStreamEventNames", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.LocalMicrophoneTrack;
+    return _webrtcCore.LocalCameraStreamEventNames;
   }
 });
-_Object$defineProperty(exports, "LocalMicrophoneTrackEvents", {
+_Object$defineProperty(exports, "LocalDisplayStream", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.LocalMicrophoneTrackEvents;
+    return _webrtcCore.LocalDisplayStream;
   }
 });
-_Object$defineProperty(exports, "LocalTrack", {
+_Object$defineProperty(exports, "LocalMicrophoneStream", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.LocalTrack;
+    return _webrtcCore.LocalMicrophoneStream;
   }
 });
-_Object$defineProperty(exports, "LocalTrackEvents", {
+_Object$defineProperty(exports, "LocalMicrophoneStreamEventNames", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.LocalTrackEvents;
+    return _webrtcCore.LocalMicrophoneStreamEventNames;
   }
 });
-_Object$defineProperty(exports, "createCameraTrack", {
+_Object$defineProperty(exports, "LocalStream", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.createCameraTrack;
+    return _webrtcCore.LocalStream;
   }
 });
-_Object$defineProperty(exports, "createDisplayTrack", {
+_Object$defineProperty(exports, "LocalStreamEventNames", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.createDisplayTrack;
+    return _webrtcCore.LocalStreamEventNames;
   }
 });
-_Object$defineProperty(exports, "createMicrophoneTrack", {
+_Object$defineProperty(exports, "LocalSystemAudioStream", {
   enumerable: true,
   get: function get() {
-    return _webrtcCore.createMicrophoneTrack;
+    return _webrtcCore.LocalSystemAudioStream;
+  }
+});
+_Object$defineProperty(exports, "NoiseReductionEffect", {
+  enumerable: true,
+  get: function get() {
+    return _webMediaEffects.NoiseReductionEffect;
+  }
+});
+_Object$defineProperty(exports, "PresetCameraConstraints", {
+  enumerable: true,
+  get: function get() {
+    return _constants.PresetCameraConstraints;
+  }
+});
+_Object$defineProperty(exports, "StreamEventNames", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.StreamEventNames;
+  }
+});
+_Object$defineProperty(exports, "VirtualBackgroundEffect", {
+  enumerable: true,
+  get: function get() {
+    return _webMediaEffects.VirtualBackgroundEffect;
+  }
+});
+_Object$defineProperty(exports, "createCameraStream", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.createCameraStream;
+  }
+});
+_Object$defineProperty(exports, "createDisplayStream", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.createDisplayStream;
+  }
+});
+_Object$defineProperty(exports, "createDisplayStreamWithAudio", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.createDisplayStreamWithAudio;
+  }
+});
+_Object$defineProperty(exports, "createMicrophoneStream", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.createMicrophoneStream;
+  }
+});
+_Object$defineProperty(exports, "getDevices", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.getDevices;
   }
 });
 var _webrtcCore = require("./webrtc-core");
+var _webMediaEffects = require("@webex/web-media-effects");
+var _constants = require("./constants");
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export {\n  LocalTrack,\n  LocalDisplayTrack,\n  LocalTrackEvents,\n  type TrackMuteEvent,\n  type ServerMuteReason,\n  LocalMicrophoneTrackEvents,\n  LocalCameraTrackEvents,\n  LocalMicrophoneTrack,\n  LocalCameraTrack,\n  createMicrophoneTrack,\n  createCameraTrack,\n  createDisplayTrack,\n} from './webrtc-core';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA"}
+{"version":3,"names":["_webrtcCore","require","_webMediaEffects","_constants"],"sources":["index.ts"],"sourcesContent":["export {\n  getDevices,\n  LocalStream,\n  LocalDisplayStream,\n  LocalSystemAudioStream,\n  LocalStreamEventNames,\n  StreamEventNames,\n  type ServerMuteReason,\n  LocalMicrophoneStreamEventNames,\n  LocalCameraStreamEventNames,\n  LocalMicrophoneStream,\n  LocalCameraStream,\n  createMicrophoneStream,\n  createCameraStream,\n  createDisplayStream,\n  createDisplayStreamWithAudio,\n} from './webrtc-core';\n\nexport {NoiseReductionEffect, VirtualBackgroundEffect} from '@webex/web-media-effects';\nexport type {\n  NoiseReductionEffectOptions,\n  VirtualBackgroundEffectOptions,\n} from '@webex/web-media-effects';\n\nexport {FacingMode, DisplaySurface, PresetCameraConstraints} from './constants';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAkBA,IAAAC,gBAAA,GAAAD,OAAA;AAMA,IAAAE,UAAA,GAAAF,OAAA"}

package/dist/webrtc-core.d.ts

@@ -0,0 +1,48 @@
+import { AudioDeviceConstraints, LocalDisplayStream, LocalSystemAudioStream, LocalMicrophoneStream as WcmeLocalMicrophoneStream, LocalCameraStream as WcmeLocalCameraStream, VideoDeviceConstraints } from '@webex/internal-media-core';
+import { TypedEvent } from '@webex/ts-events';
+export { getDevices, LocalStream, LocalDisplayStream, LocalSystemAudioStream, LocalStreamEventNames, StreamEventNames, RemoteStream, } from '@webex/internal-media-core';
+export type ServerMuteReason = 'remotelyMuted' | 'clientRequestFailed' | 'localUnmuteRequired';
+export declare enum LocalMicrophoneStreamEventNames {
+    ServerMuted = "muted:byServer"
+}
+export declare enum LocalCameraStreamEventNames {
+    ServerMuted = "muted:byServer"
+}
+export declare class LocalMicrophoneStream extends WcmeLocalMicrophoneStream {
+    private unmuteAllowed;
+    [LocalMicrophoneStreamEventNames.ServerMuted]: TypedEvent<(muted: boolean, reason: ServerMuteReason) => void>;
+    /**
+     * @internal
+     */
+    setUnmuteAllowed(allowed: any): void;
+    /**
+     * @returns true if user is allowed to unmute the Stream, false otherwise
+     */
+    isUnmuteAllowed(): boolean;
+    setMuted(muted: boolean): void;
+    /**
+     * @internal
+     */
+    setServerMuted(muted: boolean, reason: ServerMuteReason): void;
+}
+export declare class LocalCameraStream extends WcmeLocalCameraStream {
+    private unmuteAllowed;
+    [LocalCameraStreamEventNames.ServerMuted]: TypedEvent<(muted: boolean, reason: ServerMuteReason) => void>;
+    /**
+     * @internal
+     */
+    setUnmuteAllowed(allowed: any): void;
+    /**
+     * @returns true if user is allowed to unmute the Stream, false otherwise
+     */
+    isUnmuteAllowed(): boolean;
+    setMuted(muted: boolean): void;
+    /**
+     * @internal
+     */
+    setServerMuted(muted: boolean, reason: ServerMuteReason): void;
+}
+export declare const createMicrophoneStream: (constraints?: AudioDeviceConstraints) => Promise<LocalMicrophoneStream>;
+export declare const createCameraStream: (constraints?: VideoDeviceConstraints) => Promise<LocalCameraStream>;
+export declare const createDisplayStream: () => Promise<LocalDisplayStream>;
+export declare const createDisplayStreamWithAudio: () => Promise<[LocalDisplayStream, LocalSystemAudioStream]>;

package/dist/webrtc-core.js

@@ -6,27 +6,51 @@ var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequ
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.LocalCameraTrackEvents = exports.LocalCameraTrack = void 0;
-_Object$defineProperty(exports, "LocalDisplayTrack", {
+exports.LocalCameraStreamEventNames = exports.LocalCameraStream = void 0;
+_Object$defineProperty(exports, "LocalDisplayStream", {
   enumerable: true,
   get: function get() {
-    return _internalMediaCore.LocalDisplayTrack;
+    return _internalMediaCore.LocalDisplayStream;
   }
 });
-exports.LocalMicrophoneTrackEvents = exports.LocalMicrophoneTrack = void 0;
-_Object$defineProperty(exports, "LocalTrack", {
+exports.LocalMicrophoneStreamEventNames = exports.LocalMicrophoneStream = void 0;
+_Object$defineProperty(exports, "LocalStream", {
   enumerable: true,
   get: function get() {
-    return _internalMediaCore.LocalTrack;
+    return _internalMediaCore.LocalStream;
   }
 });
-_Object$defineProperty(exports, "LocalTrackEvents", {
+_Object$defineProperty(exports, "LocalStreamEventNames", {
   enumerable: true,
   get: function get() {
-    return _internalMediaCore.LocalTrackEvents;
+    return _internalMediaCore.LocalStreamEventNames;
+  }
+});
+_Object$defineProperty(exports, "LocalSystemAudioStream", {
+  enumerable: true,
+  get: function get() {
+    return _internalMediaCore.LocalSystemAudioStream;
+  }
+});
+_Object$defineProperty(exports, "RemoteStream", {
+  enumerable: true,
+  get: function get() {
+    return _internalMediaCore.RemoteStream;
+  }
+});
+_Object$defineProperty(exports, "StreamEventNames", {
+  enumerable: true,
+  get: function get() {
+    return _internalMediaCore.StreamEventNames;
+  }
+});
+exports.createMicrophoneStream = exports.createDisplayStreamWithAudio = exports.createDisplayStream = exports.createCameraStream = void 0;
+_Object$defineProperty(exports, "getDevices", {
+  enumerable: true,
+  get: function get() {
+    return _internalMediaCore.getDevices;
   }
 });
-exports.createMicrophoneTrack = exports.createDisplayTrack = exports.createCameraTrack = void 0;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
 var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/assertThisInitialized"));
@@ -36,34 +60,38 @@ var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _internalMediaCore = require("@webex/internal-media-core");
+var _tsEvents = require("@webex/ts-events");
+var _LocalMicrophoneStrea, _LocalCameraStreamEve;
 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; } }
 // server forced the client to be unmuted
 // these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
-var LocalMicrophoneTrackEvents; // these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
-exports.LocalMicrophoneTrackEvents = LocalMicrophoneTrackEvents;
-(function (LocalMicrophoneTrackEvents) {
-  LocalMicrophoneTrackEvents["ServerMuted"] = "muted:byServer";
-})(LocalMicrophoneTrackEvents || (exports.LocalMicrophoneTrackEvents = LocalMicrophoneTrackEvents = {}));
-var LocalCameraTrackEvents;
-exports.LocalCameraTrackEvents = LocalCameraTrackEvents;
-(function (LocalCameraTrackEvents) {
-  LocalCameraTrackEvents["ServerMuted"] = "muted:byServer";
-})(LocalCameraTrackEvents || (exports.LocalCameraTrackEvents = LocalCameraTrackEvents = {}));
-var LocalMicrophoneTrack = /*#__PURE__*/function (_WcmeLocalMicrophoneT) {
-  (0, _inherits2.default)(LocalMicrophoneTrack, _WcmeLocalMicrophoneT);
-  var _super = _createSuper(LocalMicrophoneTrack);
-  function LocalMicrophoneTrack() {
+var LocalMicrophoneStreamEventNames; // these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
+exports.LocalMicrophoneStreamEventNames = LocalMicrophoneStreamEventNames;
+(function (LocalMicrophoneStreamEventNames) {
+  LocalMicrophoneStreamEventNames["ServerMuted"] = "muted:byServer";
+})(LocalMicrophoneStreamEventNames || (exports.LocalMicrophoneStreamEventNames = LocalMicrophoneStreamEventNames = {}));
+var LocalCameraStreamEventNames;
+exports.LocalCameraStreamEventNames = LocalCameraStreamEventNames;
+(function (LocalCameraStreamEventNames) {
+  LocalCameraStreamEventNames["ServerMuted"] = "muted:byServer";
+})(LocalCameraStreamEventNames || (exports.LocalCameraStreamEventNames = LocalCameraStreamEventNames = {}));
+_LocalMicrophoneStrea = LocalMicrophoneStreamEventNames.ServerMuted;
+var LocalMicrophoneStream = /*#__PURE__*/function (_WcmeLocalMicrophoneS) {
+  (0, _inherits2.default)(LocalMicrophoneStream, _WcmeLocalMicrophoneS);
+  var _super = _createSuper(LocalMicrophoneStream);
+  function LocalMicrophoneStream() {
     var _this;
-    (0, _classCallCheck2.default)(this, LocalMicrophoneTrack);
+    (0, _classCallCheck2.default)(this, LocalMicrophoneStream);
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
     _this = _super.call.apply(_super, [this].concat(args));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "unmuteAllowed", true);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), _LocalMicrophoneStrea, new _tsEvents.TypedEvent());
     return _this;
   }
-  (0, _createClass2.default)(LocalMicrophoneTrack, [{
+  (0, _createClass2.default)(LocalMicrophoneStream, [{
     key: "setUnmuteAllowed",
     value:
     /**
@@ -74,7 +102,7 @@ var LocalMicrophoneTrack = /*#__PURE__*/function (_WcmeLocalMicrophoneT) {
     }
 
     /**
-     * @returns true if user is allowed to unmute the track, false otherwise
+     * @returns true if user is allowed to unmute the Stream, false otherwise
      */
   }, {
     key: "isUnmuteAllowed",
@@ -89,7 +117,7 @@ var LocalMicrophoneTrack = /*#__PURE__*/function (_WcmeLocalMicrophoneT) {
           throw new Error('Unmute is not allowed');
         }
       }
-      return (0, _get2.default)((0, _getPrototypeOf2.default)(LocalMicrophoneTrack.prototype), "setMuted", this).call(this, muted);
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(LocalMicrophoneStream.prototype), "setMuted", this).call(this, muted);
     }
 
     /**
@@ -100,30 +128,29 @@ var LocalMicrophoneTrack = /*#__PURE__*/function (_WcmeLocalMicrophoneT) {
     value: function setServerMuted(muted, reason) {
       if (muted !== this.muted) {
         this.setMuted(muted);
-        this.emit(LocalMicrophoneTrackEvents.ServerMuted, {
-          muted: muted,
-          reason: reason
-        });
+        this[LocalMicrophoneStreamEventNames.ServerMuted].emit(muted, reason);
       }
     }
   }]);
-  return LocalMicrophoneTrack;
-}(_internalMediaCore.LocalMicrophoneTrack);
-exports.LocalMicrophoneTrack = LocalMicrophoneTrack;
-var LocalCameraTrack = /*#__PURE__*/function (_WcmeLocalCameraTrack) {
-  (0, _inherits2.default)(LocalCameraTrack, _WcmeLocalCameraTrack);
-  var _super2 = _createSuper(LocalCameraTrack);
-  function LocalCameraTrack() {
+  return LocalMicrophoneStream;
+}(_internalMediaCore.LocalMicrophoneStream);
+exports.LocalMicrophoneStream = LocalMicrophoneStream;
+_LocalCameraStreamEve = LocalCameraStreamEventNames.ServerMuted;
+var LocalCameraStream = /*#__PURE__*/function (_WcmeLocalCameraStrea) {
+  (0, _inherits2.default)(LocalCameraStream, _WcmeLocalCameraStrea);
+  var _super2 = _createSuper(LocalCameraStream);
+  function LocalCameraStream() {
     var _this2;
-    (0, _classCallCheck2.default)(this, LocalCameraTrack);
+    (0, _classCallCheck2.default)(this, LocalCameraStream);
     for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       args[_key2] = arguments[_key2];
     }
     _this2 = _super2.call.apply(_super2, [this].concat(args));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "unmuteAllowed", true);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), _LocalCameraStreamEve, new _tsEvents.TypedEvent());
     return _this2;
   }
-  (0, _createClass2.default)(LocalCameraTrack, [{
+  (0, _createClass2.default)(LocalCameraStream, [{
     key: "setUnmuteAllowed",
     value:
     /**
@@ -134,7 +161,7 @@ var LocalCameraTrack = /*#__PURE__*/function (_WcmeLocalCameraTrack) {
     }
 
     /**
-     * @returns true if user is allowed to unmute the track, false otherwise
+     * @returns true if user is allowed to unmute the Stream, false otherwise
      */
   }, {
     key: "isUnmuteAllowed",
@@ -149,7 +176,7 @@ var LocalCameraTrack = /*#__PURE__*/function (_WcmeLocalCameraTrack) {
           throw new Error('Unmute is not allowed');
         }
       }
-      return (0, _get2.default)((0, _getPrototypeOf2.default)(LocalCameraTrack.prototype), "setMuted", this).call(this, muted);
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(LocalCameraStream.prototype), "setMuted", this).call(this, muted);
     }
 
     /**
@@ -160,26 +187,27 @@ var LocalCameraTrack = /*#__PURE__*/function (_WcmeLocalCameraTrack) {
     value: function setServerMuted(muted, reason) {
       if (muted !== this.muted) {
         this.setMuted(muted);
-        this.emit(LocalCameraTrackEvents.ServerMuted, {
-          muted: muted,
-          reason: reason
-        });
+        this[LocalCameraStreamEventNames.ServerMuted].emit(muted, reason);
       }
     }
   }]);
-  return LocalCameraTrack;
-}(_internalMediaCore.LocalCameraTrack);
-exports.LocalCameraTrack = LocalCameraTrack;
-var createMicrophoneTrack = function createMicrophoneTrack(constraints) {
-  return (0, _internalMediaCore.createMicrophoneTrack)(LocalMicrophoneTrack, constraints);
+  return LocalCameraStream;
+}(_internalMediaCore.LocalCameraStream);
+exports.LocalCameraStream = LocalCameraStream;
+var createMicrophoneStream = function createMicrophoneStream(constraints) {
+  return (0, _internalMediaCore.createMicrophoneStream)(LocalMicrophoneStream, constraints);
+};
+exports.createMicrophoneStream = createMicrophoneStream;
+var createCameraStream = function createCameraStream(constraints) {
+  return (0, _internalMediaCore.createCameraStream)(LocalCameraStream, constraints);
 };
-exports.createMicrophoneTrack = createMicrophoneTrack;
-var createCameraTrack = function createCameraTrack(constraints) {
-  return (0, _internalMediaCore.createCameraTrack)(LocalCameraTrack, constraints);
+exports.createCameraStream = createCameraStream;
+var createDisplayStream = function createDisplayStream() {
+  return (0, _internalMediaCore.createDisplayStream)(_internalMediaCore.LocalDisplayStream);
 };
-exports.createCameraTrack = createCameraTrack;
-var createDisplayTrack = function createDisplayTrack() {
-  return (0, _internalMediaCore.createDisplayTrack)(_internalMediaCore.LocalDisplayTrack);
+exports.createDisplayStream = createDisplayStream;
+var createDisplayStreamWithAudio = function createDisplayStreamWithAudio() {
+  return (0, _internalMediaCore.createDisplayStreamWithAudio)(_internalMediaCore.LocalDisplayStream, _internalMediaCore.LocalSystemAudioStream);
 };
-exports.createDisplayTrack = createDisplayTrack;
+exports.createDisplayStreamWithAudio = createDisplayStreamWithAudio;
 //# sourceMappingURL=webrtc-core.js.map

package/dist/webrtc-core.js.map

@@ -1 +1 @@
-{"version":3,"names":["LocalMicrophoneTrackEvents","LocalCameraTrackEvents","LocalMicrophoneTrack","allowed","unmuteAllowed","muted","isUnmuteAllowed","Error","reason","setMuted","emit","ServerMuted","WcmeLocalMicrophoneTrack","LocalCameraTrack","WcmeLocalCameraTrack","createMicrophoneTrack","constraints","wcmeCreateMicrophoneTrack","createCameraTrack","wcmeCreateCameraTrack","createDisplayTrack","wcmeCreateDisplayTrack","LocalDisplayTrack"],"sources":["webrtc-core.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-misused-new */\n/* eslint-disable valid-jsdoc */\n/* eslint-disable require-jsdoc */\nimport {\n  AudioDeviceConstraints,\n  createCameraTrack as wcmeCreateCameraTrack,\n  createDisplayTrack as wcmeCreateDisplayTrack,\n  createMicrophoneTrack as wcmeCreateMicrophoneTrack,\n  LocalDisplayTrack,\n  LocalMicrophoneTrack as WcmeLocalMicrophoneTrack,\n  LocalCameraTrack as WcmeLocalCameraTrack,\n  VideoDeviceConstraints,\n} from '@webex/internal-media-core';\n\nexport {\n  LocalTrack,\n  LocalDisplayTrack,\n  LocalTrackEvents,\n  type TrackMuteEvent,\n} from '@webex/internal-media-core';\n\nexport type ServerMuteReason =\n  | 'remotelyMuted' // other user has remotely muted us\n  | 'clientRequestFailed' // client called setMuted() but server request failed\n  | 'localUnmuteRequired'; // server forced the client to be unmuted\n\n// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed\nexport enum LocalMicrophoneTrackEvents {\n  ServerMuted = 'muted:byServer',\n}\n\n// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed\nexport enum LocalCameraTrackEvents {\n  ServerMuted = 'muted:byServer',\n}\n\nexport class LocalMicrophoneTrack extends WcmeLocalMicrophoneTrack {\n  private unmuteAllowed = true;\n\n  /**\n   * @internal\n   */\n  setUnmuteAllowed(allowed) {\n    this.unmuteAllowed = allowed;\n  }\n\n  /**\n   * @returns true if user is allowed to unmute the track, false otherwise\n   */\n  isUnmuteAllowed() {\n    return this.unmuteAllowed;\n  }\n\n  setMuted(muted: boolean): void {\n    if (!muted) {\n      if (!this.isUnmuteAllowed()) {\n        throw new Error('Unmute is not allowed');\n      }\n    }\n\n    return super.setMuted(muted);\n  }\n\n  /**\n   * @internal\n   */\n  setServerMuted(muted: boolean, reason: ServerMuteReason) {\n    if (muted !== this.muted) {\n      this.setMuted(muted);\n      this.emit(LocalMicrophoneTrackEvents.ServerMuted, {muted, reason});\n    }\n  }\n}\n\nexport class LocalCameraTrack extends WcmeLocalCameraTrack {\n  private unmuteAllowed = true;\n\n  /**\n   * @internal\n   */\n  setUnmuteAllowed(allowed) {\n    this.unmuteAllowed = allowed;\n  }\n\n  /**\n   * @returns true if user is allowed to unmute the track, false otherwise\n   */\n  isUnmuteAllowed() {\n    return this.unmuteAllowed;\n  }\n\n  setMuted(muted: boolean): void {\n    if (!muted) {\n      if (!this.isUnmuteAllowed()) {\n        throw new Error('Unmute is not allowed');\n      }\n    }\n\n    return super.setMuted(muted);\n  }\n\n  /**\n   * @internal\n   */\n  setServerMuted(muted: boolean, reason: ServerMuteReason) {\n    if (muted !== this.muted) {\n      this.setMuted(muted);\n      this.emit(LocalCameraTrackEvents.ServerMuted, {muted, reason});\n    }\n  }\n}\n\nexport const createMicrophoneTrack = (constraints?: AudioDeviceConstraints) =>\n  wcmeCreateMicrophoneTrack(LocalMicrophoneTrack, constraints);\n\nexport const createCameraTrack = (constraints?: VideoDeviceConstraints) =>\n  wcmeCreateCameraTrack(LocalCameraTrack, constraints);\n\nexport const createDisplayTrack = () => wcmeCreateDisplayTrack(LocalDisplayTrack);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;AASoC;AAAA;AAYT;AAE3B;AAAA,IACYA,0BAA0B,EAItC;AAAA;AAAA,WAJYA,0BAA0B;EAA1BA,0BAA0B;AAAA,GAA1BA,0BAA0B,0CAA1BA,0BAA0B;AAAA,IAK1BC,sBAAsB;AAAA;AAAA,WAAtBA,sBAAsB;EAAtBA,sBAAsB;AAAA,GAAtBA,sBAAsB,sCAAtBA,sBAAsB;AAAA,IAIrBC,oBAAoB;EAAA;EAAA;EAAA;IAAA;IAAA;IAAA;MAAA;IAAA;IAAA;IAAA,4FACP,IAAI;IAAA;EAAA;EAAA;IAAA;IAAA;IAE5B;AACF;AACA;IACE,0BAAiBC,OAAO,EAAE;MACxB,IAAI,CAACC,aAAa,GAAGD,OAAO;IAC9B;;IAEA;AACF;AACA;EAFE;IAAA;IAAA,OAGA,2BAAkB;MAChB,OAAO,IAAI,CAACC,aAAa;IAC3B;EAAC;IAAA;IAAA,OAED,kBAASC,KAAc,EAAQ;MAC7B,IAAI,CAACA,KAAK,EAAE;QACV,IAAI,CAAC,IAAI,CAACC,eAAe,EAAE,EAAE;UAC3B,MAAM,IAAIC,KAAK,CAAC,uBAAuB,CAAC;QAC1C;MACF;MAEA,sHAAsBF,KAAK;IAC7B;;IAEA;AACF;AACA;EAFE;IAAA;IAAA,OAGA,wBAAeA,KAAc,EAAEG,MAAwB,EAAE;MACvD,IAAIH,KAAK,KAAK,IAAI,CAACA,KAAK,EAAE;QACxB,IAAI,CAACI,QAAQ,CAACJ,KAAK,CAAC;QACpB,IAAI,CAACK,IAAI,CAACV,0BAA0B,CAACW,WAAW,EAAE;UAACN,KAAK,EAALA,KAAK;UAAEG,MAAM,EAANA;QAAM,CAAC,CAAC;MACpE;IACF;EAAC;EAAA;AAAA,EAnCuCI,uCAAwB;AAAA;AAAA,IAsCrDC,gBAAgB;EAAA;EAAA;EAAA;IAAA;IAAA;IAAA;MAAA;IAAA;IAAA;IAAA,6FACH,IAAI;IAAA;EAAA;EAAA;IAAA;IAAA;IAE5B;AACF;AACA;IACE,0BAAiBV,OAAO,EAAE;MACxB,IAAI,CAACC,aAAa,GAAGD,OAAO;IAC9B;;IAEA;AACF;AACA;EAFE;IAAA;IAAA,OAGA,2BAAkB;MAChB,OAAO,IAAI,CAACC,aAAa;IAC3B;EAAC;IAAA;IAAA,OAED,kBAASC,KAAc,EAAQ;MAC7B,IAAI,CAACA,KAAK,EAAE;QACV,IAAI,CAAC,IAAI,CAACC,eAAe,EAAE,EAAE;UAC3B,MAAM,IAAIC,KAAK,CAAC,uBAAuB,CAAC;QAC1C;MACF;MAEA,kHAAsBF,KAAK;IAC7B;;IAEA;AACF;AACA;EAFE;IAAA;IAAA,OAGA,wBAAeA,KAAc,EAAEG,MAAwB,EAAE;MACvD,IAAIH,KAAK,KAAK,IAAI,CAACA,KAAK,EAAE;QACxB,IAAI,CAACI,QAAQ,CAACJ,KAAK,CAAC;QACpB,IAAI,CAACK,IAAI,CAACT,sBAAsB,CAACU,WAAW,EAAE;UAACN,KAAK,EAALA,KAAK;UAAEG,MAAM,EAANA;QAAM,CAAC,CAAC;MAChE;IACF;EAAC;EAAA;AAAA,EAnCmCM,mCAAoB;AAAA;AAsCnD,IAAMC,qBAAqB,GAAG,SAAxBA,qBAAqB,CAAIC,WAAoC;EAAA,OACxE,IAAAC,wCAAyB,EAACf,oBAAoB,EAAEc,WAAW,CAAC;AAAA;AAAC;AAExD,IAAME,iBAAiB,GAAG,SAApBA,iBAAiB,CAAIF,WAAoC;EAAA,OACpE,IAAAG,oCAAqB,EAACN,gBAAgB,EAAEG,WAAW,CAAC;AAAA;AAAC;AAEhD,IAAMI,kBAAkB,GAAG,SAArBA,kBAAkB;EAAA,OAAS,IAAAC,qCAAsB,EAACC,oCAAiB,CAAC;AAAA;AAAC"}
+{"version":3,"names":["_internalMediaCore","require","_tsEvents","_LocalMicrophoneStrea","_LocalCameraStreamEve","_createSuper","Derived","hasNativeReflectConstruct","_isNativeReflectConstruct","_createSuperInternal","Super","_getPrototypeOf2","default","result","NewTarget","constructor","_Reflect$construct","arguments","apply","_possibleConstructorReturn2","Reflect","sham","Proxy","Boolean","prototype","valueOf","call","e","LocalMicrophoneStreamEventNames","exports","LocalCameraStreamEventNames","ServerMuted","LocalMicrophoneStream","_WcmeLocalMicrophoneS","_inherits2","_super","_this","_classCallCheck2","_len","length","args","Array","_key","concat","_defineProperty2","_assertThisInitialized2","TypedEvent","_createClass2","key","value","setUnmuteAllowed","allowed","unmuteAllowed","isUnmuteAllowed","setMuted","muted","Error","_get2","setServerMuted","reason","emit","WcmeLocalMicrophoneStream","LocalCameraStream","_WcmeLocalCameraStrea","_super2","_this2","_len2","_key2","WcmeLocalCameraStream","createMicrophoneStream","constraints","wcmeCreateMicrophoneStream","createCameraStream","wcmeCreateCameraStream","createDisplayStream","wcmeCreateDisplayStream","LocalDisplayStream","createDisplayStreamWithAudio","wcmeCreateDisplayStreamWithAudio","LocalSystemAudioStream"],"sources":["webrtc-core.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-misused-new */\n/* eslint-disable valid-jsdoc */\n/* eslint-disable require-jsdoc */\nimport {\n  AudioDeviceConstraints,\n  createCameraStream as wcmeCreateCameraStream,\n  createDisplayStream as wcmeCreateDisplayStream,\n  createDisplayStreamWithAudio as wcmeCreateDisplayStreamWithAudio,\n  createMicrophoneStream as wcmeCreateMicrophoneStream,\n  LocalDisplayStream,\n  LocalSystemAudioStream,\n  LocalMicrophoneStream as WcmeLocalMicrophoneStream,\n  LocalCameraStream as WcmeLocalCameraStream,\n  VideoDeviceConstraints,\n} from '@webex/internal-media-core';\nimport {TypedEvent} from '@webex/ts-events';\n\nexport {\n  getDevices,\n  LocalStream,\n  LocalDisplayStream,\n  LocalSystemAudioStream,\n  LocalStreamEventNames,\n  StreamEventNames,\n  RemoteStream,\n} from '@webex/internal-media-core';\n\nexport type ServerMuteReason =\n  | 'remotelyMuted' // other user has remotely muted us\n  | 'clientRequestFailed' // client called setMuted() but server request failed\n  | 'localUnmuteRequired'; // server forced the client to be unmuted\n\n// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed\nexport enum LocalMicrophoneStreamEventNames {\n  ServerMuted = 'muted:byServer',\n}\n\n// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed\nexport enum LocalCameraStreamEventNames {\n  ServerMuted = 'muted:byServer',\n}\n\nexport class LocalMicrophoneStream extends WcmeLocalMicrophoneStream {\n  private unmuteAllowed = true;\n\n  [LocalMicrophoneStreamEventNames.ServerMuted] = new TypedEvent<\n    (muted: boolean, reason: ServerMuteReason) => void\n  >();\n\n  /**\n   * @internal\n   */\n  setUnmuteAllowed(allowed) {\n    this.unmuteAllowed = allowed;\n  }\n\n  /**\n   * @returns true if user is allowed to unmute the Stream, false otherwise\n   */\n  isUnmuteAllowed() {\n    return this.unmuteAllowed;\n  }\n\n  setMuted(muted: boolean): void {\n    if (!muted) {\n      if (!this.isUnmuteAllowed()) {\n        throw new Error('Unmute is not allowed');\n      }\n    }\n\n    return super.setMuted(muted);\n  }\n\n  /**\n   * @internal\n   */\n  setServerMuted(muted: boolean, reason: ServerMuteReason) {\n    if (muted !== this.muted) {\n      this.setMuted(muted);\n      this[LocalMicrophoneStreamEventNames.ServerMuted].emit(muted, reason);\n    }\n  }\n}\n\nexport class LocalCameraStream extends WcmeLocalCameraStream {\n  private unmuteAllowed = true;\n\n  [LocalCameraStreamEventNames.ServerMuted] = new TypedEvent<\n    (muted: boolean, reason: ServerMuteReason) => void\n  >();\n\n  /**\n   * @internal\n   */\n  setUnmuteAllowed(allowed) {\n    this.unmuteAllowed = allowed;\n  }\n\n  /**\n   * @returns true if user is allowed to unmute the Stream, false otherwise\n   */\n  isUnmuteAllowed() {\n    return this.unmuteAllowed;\n  }\n\n  setMuted(muted: boolean): void {\n    if (!muted) {\n      if (!this.isUnmuteAllowed()) {\n        throw new Error('Unmute is not allowed');\n      }\n    }\n\n    return super.setMuted(muted);\n  }\n\n  /**\n   * @internal\n   */\n  setServerMuted(muted: boolean, reason: ServerMuteReason) {\n    if (muted !== this.muted) {\n      this.setMuted(muted);\n      this[LocalCameraStreamEventNames.ServerMuted].emit(muted, reason);\n    }\n  }\n}\n\nexport const createMicrophoneStream = (constraints?: AudioDeviceConstraints) =>\n  wcmeCreateMicrophoneStream(LocalMicrophoneStream, constraints);\n\nexport const createCameraStream = (constraints?: VideoDeviceConstraints) =>\n  wcmeCreateCameraStream(LocalCameraStream, constraints);\n\nexport const createDisplayStream = () => wcmeCreateDisplayStream(LocalDisplayStream);\n\nexport const createDisplayStreamWithAudio = () =>\n  wcmeCreateDisplayStreamWithAudio(LocalDisplayStream, LocalSystemAudioStream);\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,5 @@
 {
   "name": "@webex/media-helpers",
-  "version": "3.0.0-bnr.4",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "main": "dist/index.js",
@@ -13,8 +12,23 @@
   "engines": {
     "node": ">=16"
   },
+  "scripts": {
+    "build:src": "yarn run -T tsc --declaration true --declarationDir ./dist",
+    "test:broken": "yarn test:style && yarn test:unit && yarn test:integration && yarn test:browser",
+    "test:browser:broken": "webex-legacy-tools test --integration --unit --runner karma",
+    "test:integration:broken": "webex-legacy-tools test --integration --runner mocha",
+    "test:style": "eslint 'src/**/*.ts' --fix",
+    "test:unit:broken": "webex-legacy-tools test --unit --runner mocha",
+    "deploy:npm": "npm publish"
+  },
   "dependencies": {
-    "@webex/internal-media-core": "1.36.0"
+    "@webex/babel-config-legacy": "workspace:^",
+    "@webex/eslint-config-legacy": "workspace:^",
+    "@webex/internal-media-core": "^2.0.0",
+    "@webex/jest-config-legacy": "workspace:^",
+    "@webex/legacy-tools": "workspace:^",
+    "@webex/ts-events": "^1.1.0",
+    "@webex/web-media-effects": "^2.12.0"
   },
   "browserify": {
     "transform": [
@@ -23,8 +37,11 @@
     ]
   },
   "devDependencies": {
+    "@babel/preset-typescript": "7.22.11",
     "@webex/test-helper-chai": "workspace:^",
     "@webex/test-helper-mock-webex": "workspace:^",
+    "eslint": "^8.24.0",
     "sinon": "^9.2.4"
-  }
+  },
+  "version": "3.0.0-next.1"
 }

package/src/constants.ts

@@ -0,0 +1,29 @@
+import {VideoDeviceConstraints} from '@webex/internal-media-core';
+
+export enum FacingMode {
+  user = 'user',
+  environment = 'environment',
+}
+
+// can be used later on when we add constraints in create display track
+export enum DisplaySurface {
+  browser = 'browser',
+  monitor = 'monitor',
+  window = 'window',
+}
+
+export const PresetCameraConstraints: {[key: string]: VideoDeviceConstraints} = {
+  '1080p': {frameRate: 30, width: 1920, height: 1080},
+
+  '720p': {frameRate: 30, width: 1280, height: 720},
+
+  '480p': {frameRate: 30, width: 640, height: 480},
+
+  '360p': {frameRate: 30, width: 640, height: 360},
+
+  '240p': {frameRate: 30, width: 320, height: 240},
+
+  '180p': {frameRate: 30, width: 320, height: 180},
+
+  '120p': {frameRate: 30, width: 160, height: 120},
+};

package/src/index.ts

@@ -1,14 +1,25 @@
 export {
-  LocalTrack,
-  LocalDisplayTrack,
-  LocalTrackEvents,
-  type TrackMuteEvent,
+  getDevices,
+  LocalStream,
+  LocalDisplayStream,
+  LocalSystemAudioStream,
+  LocalStreamEventNames,
+  StreamEventNames,
   type ServerMuteReason,
-  LocalMicrophoneTrackEvents,
-  LocalCameraTrackEvents,
-  LocalMicrophoneTrack,
-  LocalCameraTrack,
-  createMicrophoneTrack,
-  createCameraTrack,
-  createDisplayTrack,
+  LocalMicrophoneStreamEventNames,
+  LocalCameraStreamEventNames,
+  LocalMicrophoneStream,
+  LocalCameraStream,
+  createMicrophoneStream,
+  createCameraStream,
+  createDisplayStream,
+  createDisplayStreamWithAudio,
 } from './webrtc-core';
+
+export {NoiseReductionEffect, VirtualBackgroundEffect} from '@webex/web-media-effects';
+export type {
+  NoiseReductionEffectOptions,
+  VirtualBackgroundEffectOptions,
+} from '@webex/web-media-effects';
+
+export {FacingMode, DisplaySurface, PresetCameraConstraints} from './constants';

package/src/webrtc-core.ts

@@ -3,20 +3,26 @@
 /* eslint-disable require-jsdoc */
 import {
   AudioDeviceConstraints,
-  createCameraTrack as wcmeCreateCameraTrack,
-  createDisplayTrack as wcmeCreateDisplayTrack,
-  createMicrophoneTrack as wcmeCreateMicrophoneTrack,
-  LocalDisplayTrack,
-  LocalMicrophoneTrack as WcmeLocalMicrophoneTrack,
-  LocalCameraTrack as WcmeLocalCameraTrack,
+  createCameraStream as wcmeCreateCameraStream,
+  createDisplayStream as wcmeCreateDisplayStream,
+  createDisplayStreamWithAudio as wcmeCreateDisplayStreamWithAudio,
+  createMicrophoneStream as wcmeCreateMicrophoneStream,
+  LocalDisplayStream,
+  LocalSystemAudioStream,
+  LocalMicrophoneStream as WcmeLocalMicrophoneStream,
+  LocalCameraStream as WcmeLocalCameraStream,
   VideoDeviceConstraints,
 } from '@webex/internal-media-core';
+import {TypedEvent} from '@webex/ts-events';
 
 export {
-  LocalTrack,
-  LocalDisplayTrack,
-  LocalTrackEvents,
-  type TrackMuteEvent,
+  getDevices,
+  LocalStream,
+  LocalDisplayStream,
+  LocalSystemAudioStream,
+  LocalStreamEventNames,
+  StreamEventNames,
+  RemoteStream,
 } from '@webex/internal-media-core';
 
 export type ServerMuteReason =
@@ -25,18 +31,22 @@ export type ServerMuteReason =
   | 'localUnmuteRequired'; // server forced the client to be unmuted
 
 // these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
-export enum LocalMicrophoneTrackEvents {
+export enum LocalMicrophoneStreamEventNames {
   ServerMuted = 'muted:byServer',
 }
 
 // these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
-export enum LocalCameraTrackEvents {
+export enum LocalCameraStreamEventNames {
   ServerMuted = 'muted:byServer',
 }
 
-export class LocalMicrophoneTrack extends WcmeLocalMicrophoneTrack {
+export class LocalMicrophoneStream extends WcmeLocalMicrophoneStream {
   private unmuteAllowed = true;
 
+  [LocalMicrophoneStreamEventNames.ServerMuted] = new TypedEvent<
+    (muted: boolean, reason: ServerMuteReason) => void
+  >();
+
   /**
    * @internal
    */
@@ -45,7 +55,7 @@ export class LocalMicrophoneTrack extends WcmeLocalMicrophoneTrack {
   }
 
   /**
-   * @returns true if user is allowed to unmute the track, false otherwise
+   * @returns true if user is allowed to unmute the Stream, false otherwise
    */
   isUnmuteAllowed() {
     return this.unmuteAllowed;
@@ -67,14 +77,18 @@ export class LocalMicrophoneTrack extends WcmeLocalMicrophoneTrack {
   setServerMuted(muted: boolean, reason: ServerMuteReason) {
     if (muted !== this.muted) {
       this.setMuted(muted);
-      this.emit(LocalMicrophoneTrackEvents.ServerMuted, {muted, reason});
+      this[LocalMicrophoneStreamEventNames.ServerMuted].emit(muted, reason);
     }
   }
 }
 
-export class LocalCameraTrack extends WcmeLocalCameraTrack {
+export class LocalCameraStream extends WcmeLocalCameraStream {
   private unmuteAllowed = true;
 
+  [LocalCameraStreamEventNames.ServerMuted] = new TypedEvent<
+    (muted: boolean, reason: ServerMuteReason) => void
+  >();
+
   /**
    * @internal
    */
@@ -83,7 +97,7 @@ export class LocalCameraTrack extends WcmeLocalCameraTrack {
   }
 
   /**
-   * @returns true if user is allowed to unmute the track, false otherwise
+   * @returns true if user is allowed to unmute the Stream, false otherwise
    */
   isUnmuteAllowed() {
     return this.unmuteAllowed;
@@ -105,15 +119,18 @@ export class LocalCameraTrack extends WcmeLocalCameraTrack {
   setServerMuted(muted: boolean, reason: ServerMuteReason) {
     if (muted !== this.muted) {
       this.setMuted(muted);
-      this.emit(LocalCameraTrackEvents.ServerMuted, {muted, reason});
+      this[LocalCameraStreamEventNames.ServerMuted].emit(muted, reason);
     }
   }
 }
 
-export const createMicrophoneTrack = (constraints?: AudioDeviceConstraints) =>
-  wcmeCreateMicrophoneTrack(LocalMicrophoneTrack, constraints);
+export const createMicrophoneStream = (constraints?: AudioDeviceConstraints) =>
+  wcmeCreateMicrophoneStream(LocalMicrophoneStream, constraints);
+
+export const createCameraStream = (constraints?: VideoDeviceConstraints) =>
+  wcmeCreateCameraStream(LocalCameraStream, constraints);
 
-export const createCameraTrack = (constraints?: VideoDeviceConstraints) =>
-  wcmeCreateCameraTrack(LocalCameraTrack, constraints);
+export const createDisplayStream = () => wcmeCreateDisplayStream(LocalDisplayStream);
 
-export const createDisplayTrack = () => wcmeCreateDisplayTrack(LocalDisplayTrack);
+export const createDisplayStreamWithAudio = () =>
+  wcmeCreateDisplayStreamWithAudio(LocalDisplayStream, LocalSystemAudioStream);

package/test/unit/spec/webrtc-core.js

@@ -1,115 +1,145 @@
 import {assert, expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {LocalCameraTrack, LocalMicrophoneTrack, LocalMicrophoneTrackEvents, LocalCameraTrackEvents, LocalDisplayTrack, createCameraTrack, createMicrophoneTrack, createDisplayTrack} from '@webex/media-helpers';
-import * as wcmetracks from '@webex/internal-media-core';
+import {
+  LocalCameraStream,
+  LocalMicrophoneStream,
+  LocalMicrophoneStreamEventNames,
+  LocalCameraStreamEventNames,
+  LocalDisplayStream,
+  LocalSystemAudioStream,
+  createCameraStream,
+  createMicrophoneStream,
+  createDisplayStream,
+  createDisplayStreamWithAudio,
+} from '../../../src/webrtc-core';
+import * as wcmeStreams from '@webex/internal-media-core';
 
 describe('media-helpers', () => {
   describe('webrtc-core', () => {
-
     const classesToTest = [
-      {className: LocalCameraTrack, title: 'LocalCameraTrack', event: LocalCameraTrackEvents, createFn: createCameraTrack, spyFn: 'createCameraTrack'},
-      {className: LocalMicrophoneTrack, title: 'LocalMicrophoneTrack', event: LocalMicrophoneTrackEvents, createFn: createMicrophoneTrack, spyFn: 'createMicrophoneTrack'},
+      {
+        className: LocalCameraStream,
+        title: 'LocalCameraStream',
+        event: LocalCameraStreamEventNames,
+        createFn: createCameraStream,
+        spyFn: 'createCameraStream',
+      },
+      {
+        className: LocalMicrophoneStream,
+        title: 'LocalMicrophoneStream',
+        event: LocalMicrophoneStreamEventNames,
+        createFn: createMicrophoneStream,
+        spyFn: 'createMicrophoneStream',
+      },
     ];
 
     classesToTest.forEach(({className, title, event, createFn, spyFn}) =>
-    describe(title, () => {
-      const fakeStream = {
-        getTracks: sinon.stub().returns([{
-          label: 'fake track',
-          id: 'fake track id',
-          enabled: true,
-        }])
-      };
-      const track = new className(fakeStream);
-
-      afterEach(() => {
-        sinon.restore();
-      });
-
-      it('by default allows unmuting', async () => {
-        assert.equal(track.isUnmuteAllowed(), true);
-        await track.setMuted(false);
-      })
+      describe(title, () => {
+        const fakeStream = {
+          getStreams: sinon.stub().returns([
+            {
+              label: 'fake Stream',
+              id: 'fake Stream id',
+              enabled: true,
+            },
+          ]),
+        };
+        const stream = new className(fakeStream);
 
-      it('rejects setMute(false) if unmute is not allowed', async () => {
-        track.setUnmuteAllowed(false);
+        afterEach(() => {
+          sinon.restore();
+        });
 
-        assert.equal(track.isUnmuteAllowed(), false);
-        const fn = () => track.setMuted(false);
-        expect(fn).to.throw(/Unmute is not allowed/);
-      });
+        it('by default allows unmuting', async () => {
+          assert.equal(stream.isUnmuteAllowed(), true);
+          await stream.setMuted(false);
+        });
 
-      it('resolves setMute(false) if unmute is allowed', async () => {
-        track.setUnmuteAllowed(true);
+        it('rejects setMute(false) if unmute is not allowed', async () => {
+          stream.setUnmuteAllowed(false);
 
-        assert.equal(track.isUnmuteAllowed(), true);
-        await track.setMuted(false);
-      });
+          assert.equal(stream.isUnmuteAllowed(), false);
+          const fn = () => stream.setMuted(false);
+          expect(fn).to.throw(/Unmute is not allowed/);
+        });
 
-      describe('#setServerMuted', () => {
+        it('resolves setMute(false) if unmute is allowed', async () => {
+          stream.setUnmuteAllowed(true);
 
-        afterEach(() => {
-          sinon.restore();
+          assert.equal(stream.isUnmuteAllowed(), true);
+          await stream.setMuted(false);
         });
 
-        const checkSetServerMuted = async (startMute, setMute, expectedCalled) => {
-          await track.setMuted(startMute);
+        describe('#setServerMuted', () => {
+          afterEach(() => {
+            sinon.restore();
+          });
 
-          assert.equal(track.muted, startMute);
+          const checkSetServerMuted = async (startMute, setMute, expectedCalled) => {
+            await stream.setMuted(startMute);
 
-          const handler = sinon.fake();
-          track.on(event.ServerMuted, handler);
+            assert.equal(stream.muted, startMute);
 
-          await track.setServerMuted(setMute, 'remotelyMuted');
+            const handler = sinon.fake();
+            stream.on(event.ServerMuted, handler);
 
-          assert.equal(track.muted, setMute);
-          if (expectedCalled) {
-            assert.calledOnceWithExactly(handler, {muted: setMute, reason: 'remotelyMuted'});
-          } else {
-            assert.notCalled(handler);
-          }
-        };
+            await stream.setServerMuted(setMute, 'remotelyMuted');
 
-        it('tests true to false', async () => {
-          await checkSetServerMuted(true, false, true);
-        });
-  
-        it('tests false to true', async () => {
-          await checkSetServerMuted(false, true, true);
-        });
-  
-        it('tests true to true', async () => {
-          await checkSetServerMuted(true, true, false);
-        });
-  
-        it('tests false to false', async () => {
-          await checkSetServerMuted(false, false, false);
-        });
-      });
+            assert.equal(stream.muted, setMute);
+            if (expectedCalled) {
+              assert.calledOnceWithExactly(handler, {muted: setMute, reason: 'remotelyMuted'});
+            } else {
+              assert.notCalled(handler);
+            }
+          };
+
+          it('tests true to false', async () => {
+            await checkSetServerMuted(true, false, true);
+          });
+
+          it('tests false to true', async () => {
+            await checkSetServerMuted(false, true, true);
+          });
+
+          it('tests true to true', async () => {
+            await checkSetServerMuted(true, true, false);
+          });
 
-      describe('#wcmeCreateMicrophoneTrack, #wcmeCreateCameraTrack', () => {
-        it('checks creating tracks', async () => {
-          const constraints = {devideId: 'abc'};
-  
-          const spy = sinon.stub(wcmetracks, spyFn).returns('something');
-          const result = createFn(constraints);
-  
-          assert.equal(result, 'something');
-          assert.calledOnceWithExactly(spy, className, constraints);
+          it('tests false to false', async () => {
+            await checkSetServerMuted(false, false, false);
+          });
         });
-      });
 
-    })
-  );
+        describe('#wcmeCreateMicrophoneStream, #wcmeCreateCameraStream', () => {
+          it('checks creating Streams', async () => {
+            const constraints = {devideId: 'abc'};
+
+            const spy = sinon.stub(wcmeStreams, spyFn).returns('something');
+            const result = createFn(constraints);
 
-  describe('createDisplayTrack', () => {
-    it('checks createDisplayTrack', async () => {
-      const spy = sinon.stub(wcmetracks, 'createDisplayTrack').returns('something');
-      const result = createDisplayTrack();
-      assert.equal(result, 'something');
-      assert.calledOnceWithExactly(spy, LocalDisplayTrack);
+            assert.equal(result, 'something');
+            assert.calledOnceWithExactly(spy, className, constraints);
+          });
+        });
+      })
+    );
+
+    describe('createDisplayStream', () => {
+      it('checks createDisplayStream', async () => {
+        const spy = sinon.stub(wcmeStreams, 'createDisplayStream').returns('something');
+        const result = createDisplayStream();
+        assert.equal(result, 'something');
+        assert.calledOnceWithExactly(spy, LocalDisplayStream);
+      });
     });
 
+    describe('createDisplayStreamWithAudio', () => {
+      it('checks createDisplayStreamWithAudio', async () => {
+        const spy = sinon.stub(wcmeStreams, 'createDisplayStreamWithAudio').returns('something');
+        const result = createDisplayStreamWithAudio();
+        assert.equal(result, 'something');
+        assert.calledOnceWithExactly(spy, LocalDisplayStream, LocalSystemAudioStream);
+      });
+    });
   });
- });
-});
+});

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+    "extends": "../../../tsconfig.json",
+    "include": [
+        "src"
+    ],
+}