@webex/media-helpers 3.0.0-next.2 → 3.0.0-next.20

package/README.md

@@ -31,20 +31,16 @@ Noise reduction (e.g., background noise removal)
 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.
+1. Create a new camera stream instance by using createCameraStream() 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.
+3. Use addEffect() method on cameraStream to apply effect on it.
+4. Enable the effect after adding it to cameraStream using enable() method available on effect. Effect will be enabled on cameraStream.
 
 ```javascript
-import {LocalCameraTrack, VirtualBackgroundEffect} from '@webex/media-helpers';
+import {createCameraStream, 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 a new video stream.
+const cameraStream = createCameraStream(optionalVideoConstraints);
 
 // Create the effect.
 const effect = new VirtualBackgroundEffect({
@@ -54,10 +50,10 @@ const effect = new VirtualBackgroundEffect({
   quality: `LOW`,
 });
 
-// add the effect on the input camera track.
-await cameraTrack.addEffect("background-blur", effect);
+// add the effect on the input camera stream.
+await cameraStream.addEffect(effect);
 
-//enable the effect once it is added to the track
+//enable the effect once it is added to the stream
 await effect.enable()
 ```
 
@@ -65,20 +61,16 @@ await effect.enable()
 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.
+1. Create a new microphone stream instance by using createMicrophoneStream() 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.
+3. Use addEffect() method on microphoneStream to apply effect on it.
+4. Enable the effect after adding it to microphoneStream using enable() method available on effect. Effect will be enabled on microphoneStream.
 
 ```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];
+import {createMicrophoneStream, NoiseReductionEffect} from '@webex/media-helpers';
 
-const microphoneTrack = new LocalMicrophoneTrack(new MediaStream([audioTrackFromLocalStream]));
+// Create a new audio stream.
+const microphoneStream = createMicrophoneStream(optionalAudioConstraints);
 
 // Create the effect.
 const effect = new NoiseReductionEffect({
@@ -86,8 +78,8 @@ const effect = new NoiseReductionEffect({
   mode: 'WORKLET', // or 'LEGACY'
 });
 
-// add the effect on microphone track.
-await microphoneTrack.addEffect("background-noise-removal", effect);
+// add the effect on microphone stream.
+await microphoneStream.addEffect(effect);
 
 //enable the effect once it is added to the track
 await effect.enable()

package/dist/constants.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PresetCameraConstraints = exports.FacingMode = exports.DisplaySurface = void 0;
+let FacingMode = exports.FacingMode = /*#__PURE__*/function (FacingMode) {
+  FacingMode["user"] = "user";
+  FacingMode["environment"] = "environment";
+  return FacingMode;
+}({}); // can be used later on when we add constraints in create display track
+let DisplaySurface = exports.DisplaySurface = /*#__PURE__*/function (DisplaySurface) {
+  DisplaySurface["browser"] = "browser";
+  DisplaySurface["monitor"] = "monitor";
+  DisplaySurface["window"] = "window";
+  return DisplaySurface;
+}({});
+const PresetCameraConstraints = exports.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
+  }
+};
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+null

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { getDevices, LocalStream, LocalDisplayStream, LocalSystemAudioStream, LocalStreamEventNames, StreamEventNames, type ServerMuteReason, LocalMicrophoneStreamEventNames, LocalCameraStreamEventNames, LocalMicrophoneStream, LocalCameraStream, createMicrophoneStream, createCameraStream, createDisplayStream, createDisplayStreamWithAudio, } from './webrtc-core';
+export { getDevices, LocalStream, LocalDisplayStream, LocalSystemAudioStream, LocalStreamEventNames, StreamEventNames, RemoteStream, type ServerMuteReason, LocalMicrophoneStreamEventNames, LocalCameraStreamEventNames, LocalMicrophoneStream, LocalCameraStream, createMicrophoneStream, createCameraStream, createDisplayStream, createDisplayStreamWithAudio, type VideoContentHint, } 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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DisplaySurface", {
+  enumerable: true,
+  get: function () {
+    return _constants.DisplaySurface;
+  }
+});
+Object.defineProperty(exports, "FacingMode", {
+  enumerable: true,
+  get: function () {
+    return _constants.FacingMode;
+  }
+});
+Object.defineProperty(exports, "LocalCameraStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalCameraStream;
+  }
+});
+Object.defineProperty(exports, "LocalCameraStreamEventNames", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalCameraStreamEventNames;
+  }
+});
+Object.defineProperty(exports, "LocalDisplayStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalDisplayStream;
+  }
+});
+Object.defineProperty(exports, "LocalMicrophoneStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalMicrophoneStream;
+  }
+});
+Object.defineProperty(exports, "LocalMicrophoneStreamEventNames", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalMicrophoneStreamEventNames;
+  }
+});
+Object.defineProperty(exports, "LocalStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalStream;
+  }
+});
+Object.defineProperty(exports, "LocalStreamEventNames", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalStreamEventNames;
+  }
+});
+Object.defineProperty(exports, "LocalSystemAudioStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.LocalSystemAudioStream;
+  }
+});
+Object.defineProperty(exports, "NoiseReductionEffect", {
+  enumerable: true,
+  get: function () {
+    return _webMediaEffects.NoiseReductionEffect;
+  }
+});
+Object.defineProperty(exports, "PresetCameraConstraints", {
+  enumerable: true,
+  get: function () {
+    return _constants.PresetCameraConstraints;
+  }
+});
+Object.defineProperty(exports, "RemoteStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.RemoteStream;
+  }
+});
+Object.defineProperty(exports, "StreamEventNames", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.StreamEventNames;
+  }
+});
+Object.defineProperty(exports, "VirtualBackgroundEffect", {
+  enumerable: true,
+  get: function () {
+    return _webMediaEffects.VirtualBackgroundEffect;
+  }
+});
+Object.defineProperty(exports, "createCameraStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.createCameraStream;
+  }
+});
+Object.defineProperty(exports, "createDisplayStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.createDisplayStream;
+  }
+});
+Object.defineProperty(exports, "createDisplayStreamWithAudio", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.createDisplayStreamWithAudio;
+  }
+});
+Object.defineProperty(exports, "createMicrophoneStream", {
+  enumerable: true,
+  get: function () {
+    return _webrtcCore.createMicrophoneStream;
+  }
+});
+Object.defineProperty(exports, "getDevices", {
+  enumerable: true,
+  get: function () {
+    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

@@ -0,0 +1 @@
+null

package/dist/webrtc-core.d.ts

@@ -1,6 +1,6 @@
 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';
+import { TypedEvent, WithEventsDummyType } from '@webex/ts-events';
+export { getDevices, LocalStream, LocalDisplayStream, LocalSystemAudioStream, LocalStreamEventNames, StreamEventNames, RemoteStream, type VideoContentHint, } from '@webex/internal-media-core';
 export type ServerMuteReason = 'remotelyMuted' | 'clientRequestFailed' | 'localUnmuteRequired';
 export declare enum LocalMicrophoneStreamEventNames {
     ServerMuted = "muted:byServer"
@@ -8,41 +8,51 @@ export declare enum LocalMicrophoneStreamEventNames {
 export declare enum LocalCameraStreamEventNames {
     ServerMuted = "muted:byServer"
 }
-export declare class LocalMicrophoneStream extends WcmeLocalMicrophoneStream {
+interface LocalMicrophoneStreamEvents {
+    [LocalMicrophoneStreamEventNames.ServerMuted]: TypedEvent<(muted: boolean, reason: ServerMuteReason) => void>;
+}
+interface LocalCameraStreamEvents {
+    [LocalMicrophoneStreamEventNames.ServerMuted]: TypedEvent<(muted: boolean, reason: ServerMuteReason) => void>;
+}
+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
+     * @returns true if user is allowed to unmute the track, false otherwise
      */
     isUnmuteAllowed(): boolean;
     setMuted(muted: boolean): void;
-    /**
-     * @internal
-     */
-    setServerMuted(muted: boolean, reason: ServerMuteReason): void;
 }
-export declare class LocalCameraStream extends WcmeLocalCameraStream {
+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
+     * @returns true if user is allowed to unmute the track, 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 createMicrophoneStream: (constraints?: AudioDeviceConstraints) => Promise<{
+    on<K extends LocalMicrophoneStreamEventNames.ServerMuted, E extends LocalMicrophoneStreamEvents[K] extends infer T ? T extends LocalMicrophoneStreamEvents[K] ? T extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K, handler: E): void;
+    once<K_1 extends LocalMicrophoneStreamEventNames.ServerMuted, E_1 extends LocalMicrophoneStreamEvents[K_1] extends infer T_1 ? T_1 extends LocalMicrophoneStreamEvents[K_1] ? T_1 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_1, handler: E_1): void;
+    off<K_2 extends LocalMicrophoneStreamEventNames.ServerMuted, E_2 extends LocalMicrophoneStreamEvents[K_2] extends infer T_2 ? T_2 extends LocalMicrophoneStreamEvents[K_2] ? T_2 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_2, handler: E_2): void;
+} & _LocalMicrophoneStream>;
+export declare const createCameraStream: (constraints?: VideoDeviceConstraints) => Promise<{
+    on<K extends LocalMicrophoneStreamEventNames.ServerMuted, E extends LocalCameraStreamEvents[K] extends infer T ? T extends LocalCameraStreamEvents[K] ? T extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K, handler: E): void;
+    once<K_1 extends LocalMicrophoneStreamEventNames.ServerMuted, E_1 extends LocalCameraStreamEvents[K_1] extends infer T_1 ? T_1 extends LocalCameraStreamEvents[K_1] ? T_1 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_1, handler: E_1): void;
+    off<K_2 extends LocalMicrophoneStreamEventNames.ServerMuted, E_2 extends LocalCameraStreamEvents[K_2] extends infer T_2 ? T_2 extends LocalCameraStreamEvents[K_2] ? T_2 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_2, handler: E_2): void;
+} & _LocalCameraStream>;
 export declare const createDisplayStream: () => Promise<LocalDisplayStream>;
 export declare const createDisplayStreamWithAudio: () => Promise<[LocalDisplayStream, LocalSystemAudioStream]>;
+export declare const LocalMicrophoneStream: (new (...args: any[]) => {
+    on<K extends LocalMicrophoneStreamEventNames.ServerMuted, E extends LocalMicrophoneStreamEvents[K] extends infer T ? T extends LocalMicrophoneStreamEvents[K] ? T extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K, handler: E): void;
+    once<K_1 extends LocalMicrophoneStreamEventNames.ServerMuted, E_1 extends LocalMicrophoneStreamEvents[K_1] extends infer T_1 ? T_1 extends LocalMicrophoneStreamEvents[K_1] ? T_1 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_1, handler: E_1): void;
+    off<K_2 extends LocalMicrophoneStreamEventNames.ServerMuted, E_2 extends LocalMicrophoneStreamEvents[K_2] extends infer T_2 ? T_2 extends LocalMicrophoneStreamEvents[K_2] ? T_2 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_2, handler: E_2): void;
+}) & typeof _LocalMicrophoneStream;
+export type LocalMicrophoneStream = _LocalMicrophoneStream & WithEventsDummyType<LocalMicrophoneStreamEvents>;
+export declare const LocalCameraStream: (new (...args: any[]) => {
+    on<K extends LocalMicrophoneStreamEventNames.ServerMuted, E extends LocalCameraStreamEvents[K] extends infer T ? T extends LocalCameraStreamEvents[K] ? T extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K, handler: E): void;
+    once<K_1 extends LocalMicrophoneStreamEventNames.ServerMuted, E_1 extends LocalCameraStreamEvents[K_1] extends infer T_1 ? T_1 extends LocalCameraStreamEvents[K_1] ? T_1 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_1, handler: E_1): void;
+    off<K_2 extends LocalMicrophoneStreamEventNames.ServerMuted, E_2 extends LocalCameraStreamEvents[K_2] extends infer T_2 ? T_2 extends LocalCameraStreamEvents[K_2] ? T_2 extends TypedEvent<infer X extends (...args: any[]) => void> ? X : never : never : never>(eventName: K_2, handler: E_2): void;
+}) & typeof _LocalCameraStream;
+export type LocalCameraStream = _LocalCameraStream & WithEventsDummyType<LocalCameraStreamEvents>;

package/dist/webrtc-core.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalCameraStreamEventNames = exports.LocalCameraStream = void 0;
+Object.defineProperty(exports, "LocalDisplayStream", {
+  enumerable: true,
+  get: function () {
+    return _internalMediaCore.LocalDisplayStream;
+  }
+});
+exports.LocalMicrophoneStreamEventNames = exports.LocalMicrophoneStream = void 0;
+Object.defineProperty(exports, "LocalStream", {
+  enumerable: true,
+  get: function () {
+    return _internalMediaCore.LocalStream;
+  }
+});
+Object.defineProperty(exports, "LocalStreamEventNames", {
+  enumerable: true,
+  get: function () {
+    return _internalMediaCore.LocalStreamEventNames;
+  }
+});
+Object.defineProperty(exports, "LocalSystemAudioStream", {
+  enumerable: true,
+  get: function () {
+    return _internalMediaCore.LocalSystemAudioStream;
+  }
+});
+Object.defineProperty(exports, "RemoteStream", {
+  enumerable: true,
+  get: function () {
+    return _internalMediaCore.RemoteStream;
+  }
+});
+Object.defineProperty(exports, "StreamEventNames", {
+  enumerable: true,
+  get: function () {
+    return _internalMediaCore.StreamEventNames;
+  }
+});
+exports.createMicrophoneStream = exports.createDisplayStreamWithAudio = exports.createDisplayStream = exports.createCameraStream = void 0;
+Object.defineProperty(exports, "getDevices", {
+  enumerable: true,
+  get: function () {
+    return _internalMediaCore.getDevices;
+  }
+});
+var _internalMediaCore = require("@webex/internal-media-core");
+var _tsEvents = require("@webex/ts-events");
+/* eslint-disable @typescript-eslint/no-misused-new */
+/* eslint-disable valid-jsdoc */
+/* eslint-disable require-jsdoc */
+// 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
+let LocalMicrophoneStreamEventNames = exports.LocalMicrophoneStreamEventNames = /*#__PURE__*/function (LocalMicrophoneStreamEventNames) {
+  LocalMicrophoneStreamEventNames["ServerMuted"] = "muted:byServer";
+  return LocalMicrophoneStreamEventNames;
+}({}); // these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
+let LocalCameraStreamEventNames = exports.LocalCameraStreamEventNames = /*#__PURE__*/function (LocalCameraStreamEventNames) {
+  LocalCameraStreamEventNames["ServerMuted"] = "muted:byServer";
+  return LocalCameraStreamEventNames;
+}({});
+class _LocalMicrophoneStream extends _internalMediaCore.LocalMicrophoneStream {
+  unmuteAllowed = true;
+  [LocalMicrophoneStreamEventNames.ServerMuted] = new _tsEvents.TypedEvent();
+
+  /**
+   * @internal
+   */
+  setUnmuteAllowed(allowed) {
+    this.unmuteAllowed = allowed;
+  }
+
+  /**
+   * @returns true if user is allowed to unmute the track, false otherwise
+   */
+  isUnmuteAllowed() {
+    return this.unmuteAllowed;
+  }
+  setMuted(muted) {
+    if (!muted) {
+      if (!this.isUnmuteAllowed()) {
+        throw new Error('Unmute is not allowed');
+      }
+    }
+    return super.setMuted(muted);
+  }
+
+  /**
+   * @internal
+   */
+  setServerMuted(muted, reason) {
+    if (muted !== this.muted) {
+      this.setMuted(muted);
+      this[LocalMicrophoneStreamEventNames.ServerMuted].emit(muted, reason);
+    }
+  }
+}
+class _LocalCameraStream extends _internalMediaCore.LocalCameraStream {
+  unmuteAllowed = true;
+  [LocalCameraStreamEventNames.ServerMuted] = new _tsEvents.TypedEvent();
+
+  /**
+   * @internal
+   */
+  setUnmuteAllowed(allowed) {
+    this.unmuteAllowed = allowed;
+  }
+
+  /**
+   * @returns true if user is allowed to unmute the track, false otherwise
+   */
+  isUnmuteAllowed() {
+    return this.unmuteAllowed;
+  }
+  setMuted(muted) {
+    if (!muted) {
+      if (!this.isUnmuteAllowed()) {
+        throw new Error('Unmute is not allowed');
+      }
+    }
+    return super.setMuted(muted);
+  }
+
+  /**
+   * @internal
+   */
+  setServerMuted(muted, reason) {
+    if (muted !== this.muted) {
+      this.setMuted(muted);
+      this[LocalCameraStreamEventNames.ServerMuted].emit(muted, reason);
+    }
+  }
+}
+const createMicrophoneStream = constraints => (0, _internalMediaCore.createMicrophoneStream)(LocalMicrophoneStream, constraints);
+exports.createMicrophoneStream = createMicrophoneStream;
+const createCameraStream = constraints => (0, _internalMediaCore.createCameraStream)(LocalCameraStream, constraints);
+exports.createCameraStream = createCameraStream;
+const createDisplayStream = () => (0, _internalMediaCore.createDisplayStream)(_internalMediaCore.LocalDisplayStream);
+exports.createDisplayStream = createDisplayStream;
+const createDisplayStreamWithAudio = () => (0, _internalMediaCore.createDisplayStreamWithAudio)(_internalMediaCore.LocalDisplayStream, _internalMediaCore.LocalSystemAudioStream);
+exports.createDisplayStreamWithAudio = createDisplayStreamWithAudio;
+const LocalMicrophoneStream = exports.LocalMicrophoneStream = (0, _tsEvents.AddEvents)(_LocalMicrophoneStream);
+const LocalCameraStream = exports.LocalCameraStream = (0, _tsEvents.AddEvents)(_LocalCameraStream);
+//# sourceMappingURL=webrtc-core.js.map

package/dist/webrtc-core.js.map

@@ -0,0 +1 @@
+null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/media-helpers",
-  "description": "",
+  "description": "Package that provides helper functions for media related activities.",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "main": "dist/index.js",
   "devMain": "src/index.ts",
@@ -13,22 +13,19 @@
     "node": ">=16"
   },
   "scripts": {
-    "build:src": "yarn run -T tsc --declaration true --declarationDir ./dist",
+    "build": "yarn run -T tsc --declaration true --declarationDir ./dist",
+    "build:src": "webex-legacy-tools build -dest \"./dist\" -src \"./src\" -js -ts -maps && 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"
+    "deploy:npm": "yarn npm publish"
   },
   "dependencies": {
-    "@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/internal-media-core": "2.2.6",
     "@webex/ts-events": "^1.1.0",
-    "@webex/web-media-effects": "^2.12.0"
+    "@webex/web-media-effects": "^2.15.6"
   },
   "browserify": {
     "transform": [
@@ -38,10 +35,14 @@
   },
   "devDependencies": {
     "@babel/preset-typescript": "7.22.11",
-    "@webex/test-helper-chai": "workspace:^",
-    "@webex/test-helper-mock-webex": "workspace:^",
+    "@webex/babel-config-legacy": "0.0.0",
+    "@webex/eslint-config-legacy": "0.0.0",
+    "@webex/jest-config-legacy": "0.0.0",
+    "@webex/legacy-tools": "0.0.0",
+    "@webex/test-helper-chai": "2.60.1-next.1",
+    "@webex/test-helper-mock-webex": "2.60.1-next.1",
     "eslint": "^8.24.0",
     "sinon": "^9.2.4"
   },
-  "version": "3.0.0-next.2"
-}
+  "version": "3.0.0-next.20"
+}

package/src/index.ts

@@ -5,6 +5,7 @@ export {
   LocalSystemAudioStream,
   LocalStreamEventNames,
   StreamEventNames,
+  RemoteStream,
   type ServerMuteReason,
   LocalMicrophoneStreamEventNames,
   LocalCameraStreamEventNames,
@@ -14,6 +15,7 @@ export {
   createCameraStream,
   createDisplayStream,
   createDisplayStreamWithAudio,
+  type VideoContentHint,
 } from './webrtc-core';
 
 export {NoiseReductionEffect, VirtualBackgroundEffect} from '@webex/web-media-effects';

package/src/webrtc-core.ts

@@ -13,7 +13,7 @@ import {
   LocalCameraStream as WcmeLocalCameraStream,
   VideoDeviceConstraints,
 } from '@webex/internal-media-core';
-import {TypedEvent} from '@webex/ts-events';
+import {AddEvents, TypedEvent, WithEventsDummyType} from '@webex/ts-events';
 
 export {
   getDevices,
@@ -23,6 +23,7 @@ export {
   LocalStreamEventNames,
   StreamEventNames,
   RemoteStream,
+  type VideoContentHint,
 } from '@webex/internal-media-core';
 
 export type ServerMuteReason =
@@ -40,7 +41,19 @@ export enum LocalCameraStreamEventNames {
   ServerMuted = 'muted:byServer',
 }
 
-export class LocalMicrophoneStream extends WcmeLocalMicrophoneStream {
+interface LocalMicrophoneStreamEvents {
+  [LocalMicrophoneStreamEventNames.ServerMuted]: TypedEvent<
+    (muted: boolean, reason: ServerMuteReason) => void
+  >;
+}
+
+interface LocalCameraStreamEvents {
+  [LocalMicrophoneStreamEventNames.ServerMuted]: TypedEvent<
+    (muted: boolean, reason: ServerMuteReason) => void
+  >;
+}
+
+class _LocalMicrophoneStream extends WcmeLocalMicrophoneStream {
   private unmuteAllowed = true;
 
   [LocalMicrophoneStreamEventNames.ServerMuted] = new TypedEvent<
@@ -50,12 +63,12 @@ export class LocalMicrophoneStream extends WcmeLocalMicrophoneStream {
   /**
    * @internal
    */
-  setUnmuteAllowed(allowed) {
+  setUnmuteAllowed(allowed: boolean) {
     this.unmuteAllowed = allowed;
   }
 
   /**
-   * @returns true if user is allowed to unmute the Stream, false otherwise
+   * @returns true if user is allowed to unmute the track, false otherwise
    */
   isUnmuteAllowed() {
     return this.unmuteAllowed;
@@ -82,7 +95,7 @@ export class LocalMicrophoneStream extends WcmeLocalMicrophoneStream {
   }
 }
 
-export class LocalCameraStream extends WcmeLocalCameraStream {
+class _LocalCameraStream extends WcmeLocalCameraStream {
   private unmuteAllowed = true;
 
   [LocalCameraStreamEventNames.ServerMuted] = new TypedEvent<
@@ -92,12 +105,12 @@ export class LocalCameraStream extends WcmeLocalCameraStream {
   /**
    * @internal
    */
-  setUnmuteAllowed(allowed) {
+  setUnmuteAllowed(allowed: boolean) {
     this.unmuteAllowed = allowed;
   }
 
   /**
-   * @returns true if user is allowed to unmute the Stream, false otherwise
+   * @returns true if user is allowed to unmute the track, false otherwise
    */
   isUnmuteAllowed() {
     return this.unmuteAllowed;
@@ -134,3 +147,17 @@ export const createDisplayStream = () => wcmeCreateDisplayStream(LocalDisplayStr
 
 export const createDisplayStreamWithAudio = () =>
   wcmeCreateDisplayStreamWithAudio(LocalDisplayStream, LocalSystemAudioStream);
+
+export const LocalMicrophoneStream = AddEvents<
+  typeof _LocalMicrophoneStream,
+  LocalMicrophoneStreamEvents
+>(_LocalMicrophoneStream);
+
+export type LocalMicrophoneStream = _LocalMicrophoneStream &
+  WithEventsDummyType<LocalMicrophoneStreamEvents>;
+
+export const LocalCameraStream = AddEvents<typeof _LocalCameraStream, LocalCameraStreamEvents>(
+  _LocalCameraStream
+);
+
+export type LocalCameraStream = _LocalCameraStream & WithEventsDummyType<LocalCameraStreamEvents>;

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

@@ -11,8 +11,8 @@ import {
   createMicrophoneStream,
   createDisplayStream,
   createDisplayStreamWithAudio,
-} from '../../../src/webrtc-core';
-import * as wcmeStreams from '@webex/internal-media-core';
+} from '@webex/media-helpers';
+import * as wcmestreams from '@webex/internal-media-core';
 
 describe('media-helpers', () => {
   describe('webrtc-core', () => {
@@ -36,11 +36,13 @@ describe('media-helpers', () => {
     classesToTest.forEach(({className, title, event, createFn, spyFn}) =>
       describe(title, () => {
         const fakeStream = {
-          getStreams: sinon.stub().returns([
+          getTracks: sinon.stub().returns([
             {
-              label: 'fake Stream',
-              id: 'fake Stream id',
+              label: 'fake track',
+              id: 'fake track id',
               enabled: true,
+              muted: false,
+              addEventListener: sinon.stub(),
             },
           ]),
         };
@@ -70,51 +72,55 @@ describe('media-helpers', () => {
           await stream.setMuted(false);
         });
 
+        it('returns a reasonable length string from JSON.stringify()', () => {
+          assert.isBelow(JSON.stringify(stream).length, 200);
+        });
+
         describe('#setServerMuted', () => {
           afterEach(() => {
             sinon.restore();
           });
 
-          const checkSetServerMuted = async (startMute, setMute, expectedCalled) => {
-            await stream.setMuted(startMute);
+          const checkSetServerMuted = (startMute, setMute, expectedCalled) => {
+            stream.setMuted(startMute);
 
             assert.equal(stream.muted, startMute);
 
             const handler = sinon.fake();
             stream.on(event.ServerMuted, handler);
 
-            await stream.setServerMuted(setMute, 'remotelyMuted');
+            stream.setServerMuted(setMute, 'remotelyMuted');
 
             assert.equal(stream.muted, setMute);
             if (expectedCalled) {
-              assert.calledOnceWithExactly(handler, {muted: setMute, reason: 'remotelyMuted'});
+              assert.calledOnceWithExactly(handler, setMute, 'remotelyMuted');
             } else {
               assert.notCalled(handler);
             }
           };
 
           it('tests true to false', async () => {
-            await checkSetServerMuted(true, false, true);
+            checkSetServerMuted(true, false, true);
           });
 
           it('tests false to true', async () => {
-            await checkSetServerMuted(false, true, true);
+            checkSetServerMuted(false, true, true);
           });
 
           it('tests true to true', async () => {
-            await checkSetServerMuted(true, true, false);
+            checkSetServerMuted(true, true, false);
           });
 
           it('tests false to false', async () => {
-            await checkSetServerMuted(false, false, false);
+            checkSetServerMuted(false, false, false);
           });
         });
 
         describe('#wcmeCreateMicrophoneStream, #wcmeCreateCameraStream', () => {
-          it('checks creating Streams', async () => {
-            const constraints = {devideId: 'abc'};
+          it('checks creating tracks', async () => {
+            const constraints = {deviceId: 'abc'};
 
-            const spy = sinon.stub(wcmeStreams, spyFn).returns('something');
+            const spy = sinon.stub(wcmestreams, spyFn).returns('something');
             const result = createFn(constraints);
 
             assert.equal(result, 'something');
@@ -126,7 +132,7 @@ describe('media-helpers', () => {
 
     describe('createDisplayStream', () => {
       it('checks createDisplayStream', async () => {
-        const spy = sinon.stub(wcmeStreams, 'createDisplayStream').returns('something');
+        const spy = sinon.stub(wcmestreams, 'createDisplayStream').returns('something');
         const result = createDisplayStream();
         assert.equal(result, 'something');
         assert.calledOnceWithExactly(spy, LocalDisplayStream);
@@ -135,7 +141,7 @@ describe('media-helpers', () => {
 
     describe('createDisplayStreamWithAudio', () => {
       it('checks createDisplayStreamWithAudio', async () => {
-        const spy = sinon.stub(wcmeStreams, 'createDisplayStreamWithAudio').returns('something');
+        const spy = sinon.stub(wcmestreams, 'createDisplayStreamWithAudio').returns('something');
         const result = createDisplayStreamWithAudio();
         assert.equal(result, 'something');
         assert.calledOnceWithExactly(spy, LocalDisplayStream, LocalSystemAudioStream);