@whereby.com/core 1.2.8 → 1.3.0

package/dist/redux/index.cjs

@@ -75,9 +75,9 @@ const createReactor = (selectors, callback) => {
     });
 };
 
-const coreVersion = "1.2.8";
+const coreVersion = "1.3.0";
 
-const initialState = {
+const initialState$1 = {
     isNodeSdk: false,
     isActive: false,
     isDialIn: false,
@@ -91,7 +91,7 @@ const initialState = {
 };
 const appSlice = toolkit.createSlice({
     name: "app",
-    initialState,
+    initialState: initialState$1,
     reducers: {
         doAppStart: (state, action) => {
             const url = new URL(action.payload.roomUrl);
@@ -592,6 +592,12 @@ const localMediaSlice = toolkit.createSlice({
         builder.addCase(doSwitchLocalStream.rejected, (state) => {
             return Object.assign(Object.assign({}, state), { isSwitchingStream: false });
         });
+        builder.addCase(doLocalStreamEffect.fulfilled, (state, { payload }) => {
+            if (!payload) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { beforeEffectTracks: Object.assign(Object.assign({}, state.beforeEffectTracks), payload.beforeEffectTracks) });
+        });
     },
 });
 const { deviceBusy, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setCurrentSpeakerDeviceId, toggleCameraEnabled, toggleMicrophoneEnabled, toggleLowDataModeEnabled, setLocalMediaOptions, setLocalMediaStream, localMediaStopped, localStreamMetadataUpdated, } = localMediaSlice.actions;
@@ -721,6 +727,15 @@ const doSwitchLocalStream = createAppAsyncThunk("localMedia/doSwitchLocalStream"
     if (!replaceStream) {
         return;
     }
+    const beforeEffectTracks = selectLocalMediaBeforeEffectTracks(state);
+    if (audioId !== undefined && (beforeEffectTracks === null || beforeEffectTracks === void 0 ? void 0 : beforeEffectTracks.audio)) {
+        beforeEffectTracks.audio.stop();
+        beforeEffectTracks.audio = undefined;
+    }
+    if (videoId !== undefined && (beforeEffectTracks === null || beforeEffectTracks === void 0 ? void 0 : beforeEffectTracks.video)) {
+        beforeEffectTracks.video.stop();
+        beforeEffectTracks.video = undefined;
+    }
     try {
         const { replacedTracks } = yield media.getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: audioId === undefined ? false : audioId, videoId: videoId === undefined ? false : videoId, type: "exact" }), { replaceStream });
         const deviceId = audioId || videoId;
@@ -729,7 +744,7 @@ const doSwitchLocalStream = createAppAsyncThunk("localMedia/doSwitchLocalStream"
                 deviceId,
             }));
         }
-        return { replacedTracks };
+        return { replacedTracks, beforeEffectTracks };
     }
     catch (error) {
         console.error(error);
@@ -780,6 +795,46 @@ const doStopLocalMedia = createAppThunk(() => (dispatch, getState) => {
     }
     dispatch(localMediaStopped());
 });
+const doLocalStreamEffect = createAppAsyncThunk("localMedia/doLocalStreamEffect", (_a, _b) => __awaiter(void 0, [_a, _b], void 0, function* ({ effectStream, only, stopBeforeTrack, }, { getState }) {
+    var _c;
+    const state = getState();
+    let beforeEffectTracks = selectLocalMediaBeforeEffectTracks(state);
+    const beforeTrack = beforeEffectTracks === null || beforeEffectTracks === void 0 ? void 0 : beforeEffectTracks[only];
+    if (!effectStream && !beforeTrack)
+        return;
+    try {
+        const stream = selectLocalMediaStream(state);
+        let replacedTracks = null;
+        if (!stream) {
+            throw new Error("No local media stream");
+        }
+        if (effectStream) {
+            if (!beforeTrack) {
+                beforeEffectTracks = {
+                    [only]: (_c = (only === "audio" ? stream === null || stream === void 0 ? void 0 : stream.getAudioTracks() : stream === null || stream === void 0 ? void 0 : stream.getVideoTracks())) === null || _c === void 0 ? void 0 : _c[0],
+                };
+            }
+            replacedTracks = media.replaceTracksInStream(stream, effectStream, only);
+        }
+        else if (!stopBeforeTrack) {
+            replacedTracks = media.replaceTracksInStream(stream, beforeTrack ? new MediaStream([beforeTrack]) : new MediaStream(), only);
+            beforeEffectTracks = {
+                [only]: undefined,
+            };
+        }
+        else if (beforeTrack) {
+            beforeEffectTracks = {
+                [only]: undefined,
+            };
+            beforeTrack.stop();
+        }
+        return { effectStream, beforeEffectTracks, replacedTracks };
+    }
+    catch (error) {
+        console.error("Error applying local stream effect", error);
+        return;
+    }
+}));
 const selectBusyDeviceIds = (state) => state.localMedia.busyDeviceIds;
 const selectCameraDeviceError = (state) => state.localMedia.cameraDeviceError;
 const selectCurrentCameraDeviceId = (state) => state.localMedia.currentCameraDeviceId;
@@ -800,6 +855,7 @@ const selectLocalMediaStream = (state) => state.localMedia.stream;
 const selectMicrophoneDeviceError = (state) => state.localMedia.microphoneDeviceError;
 const selectLocalMediaStartError = (state) => state.localMedia.startError;
 const selectLocalMediaIsSwitchingStream = (state) => state.localMedia.isSwitchingStream;
+const selectLocalMediaBeforeEffectTracks = (state) => state.localMedia.beforeEffectTracks;
 const selectLocalMediaConstraintsOptions = toolkit.createSelector(selectLocalMediaDevices, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectIsLowDataModeEnabled, (devices, videoId, audioId, lowDataMode) => ({
     devices,
     videoId,
@@ -896,7 +952,7 @@ startAppListening({
     },
 });
 startAppListening({
-    matcher: toolkit.isAnyOf(doStartLocalMedia.fulfilled, doUpdateDeviceList.fulfilled, doSwitchLocalStream.fulfilled, doSwitchLocalStream.rejected),
+    matcher: toolkit.isAnyOf(doStartLocalMedia.fulfilled, doUpdateDeviceList.fulfilled, doSwitchLocalStream.fulfilled, doSwitchLocalStream.rejected, doLocalStreamEffect.fulfilled),
     effect: (_action, { dispatch, getState }) => {
         const state = getState();
         const stream = selectLocalMediaStream(state);
@@ -1960,7 +2016,7 @@ startAppListening({
     },
 });
 startAppListening({
-    actionCreator: doSwitchLocalStream.fulfilled,
+    matcher: toolkit.isAnyOf(doSwitchLocalStream.fulfilled, doLocalStreamEffect.fulfilled),
     effect: ({ payload }, { getState }) => {
         var _a;
         const stream = selectLocalMediaStream(getState());
@@ -2988,11 +3044,107 @@ const doRejectWaitingParticipant = createRoomConnectedThunk((payload) => (dispat
 const selectWaitingParticipantsRaw = (state) => state.waitingParticipants;
 const selectWaitingParticipants = (state) => state.waitingParticipants.waitingParticipants;
 
+const initialState = {
+    isSwitching: false,
+    raw: {},
+};
+const cameraEffectsSlice = toolkit.createSlice({
+    name: "cameraEffects",
+    initialState,
+    reducers: {
+        cameraEffectsSwitching(state, action) {
+            state.isSwitching = action.payload.isSwitching;
+        },
+        cameraEffectsCleared(state) {
+            state.currentEffectId = null;
+            state.setup = undefined;
+            state.params = undefined;
+            state.raw = {};
+            state.error = undefined;
+            state.isSwitching = false;
+        },
+        cameraEffectsUpdated(state, action) {
+            const { effectId, setup, params, raw } = action.payload;
+            state.currentEffectId = effectId;
+            state.setup = setup;
+            state.params = params;
+            if (raw)
+                state.raw = raw;
+            state.error = undefined;
+            state.isSwitching = false;
+        },
+        cameraEffectsError(state, action) {
+            state.error = action.payload.error;
+            state.isSwitching = false;
+        },
+    },
+});
+const { cameraEffectsSwitching, cameraEffectsCleared, cameraEffectsUpdated, cameraEffectsError } = cameraEffectsSlice.actions;
+const selectCameraEffectsRaw = (state) => state.cameraEffects.raw;
+const doCameraEffectsSwitchPreset = createAppAsyncThunk("cameraEffects/switchPreset", (_a, _b) => __awaiter(void 0, [_a, _b], void 0, function* ({ effectId, setup, params, allowSafari, }, { getState, dispatch, rejectWithValue }) {
+    var _c, _d, _e;
+    const state = getState();
+    if (selectLocalMediaIsSwitchingStream(state)) {
+        return;
+    }
+    dispatch(cameraEffectsSwitching({ isSwitching: true }));
+    try {
+        const raw = selectCameraEffectsRaw(state);
+        const localStream = selectLocalMediaStream(state);
+        if (!((_c = localStream === null || localStream === void 0 ? void 0 : localStream.getVideoTracks()) === null || _c === void 0 ? void 0 : _c[0])) {
+            dispatch(cameraEffectsCleared());
+            return;
+        }
+        if (!effectId) {
+            if (raw.effectStream) {
+                yield dispatch(doLocalStreamEffect({ effectStream: undefined, only: "video" }));
+            }
+            (_d = raw.stop) === null || _d === void 0 ? void 0 : _d.call(raw);
+            dispatch(cameraEffectsCleared());
+            return;
+        }
+        if (raw.tryUpdate) {
+            const ok = yield raw.tryUpdate(effectId, Object.assign({}, (setup || {})), Object.assign({}, (params || {})));
+            if (ok) {
+                dispatch(cameraEffectsUpdated({ effectId, setup, params }));
+                return;
+            }
+        }
+        if (raw.effectStream) {
+            yield dispatch(doLocalStreamEffect({ effectStream: undefined, only: "video" }));
+            (_e = raw.stop) === null || _e === void 0 ? void 0 : _e.call(raw);
+        }
+        let mod;
+        try {
+            mod = yield import('@whereby.com/camera-effects');
+        }
+        catch (_f) {
+            throw new Error("@whereby.com/camera-effects is not installed. Add it as a dependency to enable camera effects.");
+        }
+        const { createEffectStream, getUsablePresets } = mod;
+        const usable = getUsablePresets({ filter: () => true, options: { allowSafari } });
+        if (!usable.includes(effectId)) {
+            throw new Error(`Unknown or unsupported effect preset: ${effectId}`);
+        }
+        const { stream: effectStream, stop, tryUpdate, } = yield createEffectStream(localStream, effectId, setup, params);
+        yield dispatch(doLocalStreamEffect({ effectStream, only: "video" }));
+        dispatch(cameraEffectsUpdated({ effectId, setup, params, raw: { stop, tryUpdate, effectStream } }));
+    }
+    catch (error) {
+        dispatch(cameraEffectsError({ error }));
+        return rejectWithValue(error);
+    }
+}));
+createAppAsyncThunk("cameraEffects/clear", (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { dispatch }) {
+    yield dispatch(doCameraEffectsSwitchPreset({ effectId: null }));
+}));
+
 const IS_DEV = undefined === "true";
 const appReducer = toolkit.combineReducers({
     app: appSlice.reducer,
     authorization: authorizationSlice.reducer,
     breakout: breakoutSlice.reducer,
+    cameraEffects: cameraEffectsSlice.reducer,
     chat: chatSlice.reducer,
     cloudRecording: cloudRecordingSlice.reducer,
     connectionMonitor: connectionMonitorSlice.reducer,
@@ -3817,6 +3969,7 @@ exports.doHandleStreamingStarted = doHandleStreamingStarted;
 exports.doHandleStreamingStopped = doHandleStreamingStopped;
 exports.doKickParticipant = doKickParticipant;
 exports.doKnockRoom = doKnockRoom;
+exports.doLocalStreamEffect = doLocalStreamEffect;
 exports.doLockRoom = doLockRoom;
 exports.doOrganizationFetch = doOrganizationFetch;
 exports.doRejectWaitingParticipant = doRejectWaitingParticipant;
@@ -3852,7 +4005,7 @@ exports.doUpdateDeviceList = doUpdateDeviceList;
 exports.initialCloudRecordingState = initialCloudRecordingState;
 exports.initialLocalMediaState = initialLocalMediaState;
 exports.initialNotificationsState = initialNotificationsState;
-exports.initialState = initialState;
+exports.initialState = initialState$1;
 exports.isAcceptingStreams = isAcceptingStreams;
 exports.isClientSpotlighted = isClientSpotlighted;
 exports.listenerMiddleware = listenerMiddleware;
@@ -3949,6 +4102,7 @@ exports.selectIsMicrophoneEnabled = selectIsMicrophoneEnabled;
 exports.selectIsSettingCameraDevice = selectIsSettingCameraDevice;
 exports.selectIsSettingMicrophoneDevice = selectIsSettingMicrophoneDevice;
 exports.selectIsToggleCamera = selectIsToggleCamera;
+exports.selectLocalMediaBeforeEffectTracks = selectLocalMediaBeforeEffectTracks;
 exports.selectLocalMediaConstraintsOptions = selectLocalMediaConstraintsOptions;
 exports.selectLocalMediaDevices = selectLocalMediaDevices;
 exports.selectLocalMediaIsSwitchingStream = selectLocalMediaIsSwitchingStream;