@whereby.com/core 0.36.0 → 1.0.0

package/dist/redux/index.mjs

@@ -0,0 +1,3006 @@
+import { createAsyncThunk, createListenerMiddleware, addListener, createSlice, createAction, createSelector, isAnyOf, combineReducers, configureStore } from '@reduxjs/toolkit';
+import { ServerSocket, getDeviceData, getStream, getUpdatedDevices, RtcManagerDispatcher, setClientProvider, subscribeIssues } from '@whereby.com/media';
+import { EventEmitter } from 'events';
+
+function createAppAsyncThunk(typePrefix, payloadCreator) {
+    return createAsyncThunk(typePrefix, payloadCreator);
+}
+function createAppThunk(thunk) {
+    return thunk;
+}
+function createAppAuthorizedThunk(authorizationSelector, thunk) {
+    return createAppThunk((payload) => (dispatch, getState, extra) => {
+        const isAuthorized = authorizationSelector(getState());
+        if (!isAuthorized) {
+            console.warn("Not authorized to perform this action");
+            return false;
+        }
+        return thunk(payload)(dispatch, getState, extra);
+    });
+}
+function createRoomConnectedThunk(thunk) {
+    return createAppThunk((payload) => (dispatch, getState, extra) => {
+        const connectionStatus = getState().roomConnection.status;
+        if (connectionStatus !== "connected") {
+            console.warn("Action cannot be performed outside of a connected room");
+            return false;
+        }
+        return thunk(payload)(dispatch, getState, extra);
+    });
+}
+function createAsyncRoomConnectedThunk(typePrefix, payloadCreator) {
+    return createAppAsyncThunk(typePrefix, (arg, thunkApi) => {
+        const { getState } = thunkApi;
+        const connectionStatus = getState().roomConnection.status;
+        if (connectionStatus !== "connected") {
+            console.warn("Action cannot be performed outside of a connected room");
+            return Promise.reject("Action cannot be performed outside of a connected room");
+        }
+        return payloadCreator(arg, thunkApi);
+    });
+}
+function createAuthorizedRoomConnectedThunk(authorizationSelector, thunk) {
+    return createAppThunk((payload) => (dispatch, getState, extra) => {
+        const connectionStatus = getState().roomConnection.status;
+        if (connectionStatus !== "connected") {
+            console.warn("Action cannot be performed outside of a connected room");
+            return false;
+        }
+        return createAppAuthorizedThunk(authorizationSelector, thunk)(payload)(dispatch, getState, extra);
+    });
+}
+
+const listenerMiddleware = createListenerMiddleware();
+const startAppListening = listenerMiddleware.startListening;
+const addAppListener = addListener;
+const createReactor = (selectors, callback) => {
+    return startAppListening({
+        predicate: (_, currentState, previousState) => {
+            const previousValues = selectors.map((selector) => selector(previousState));
+            const currentValues = selectors.map((selector) => selector(currentState));
+            return previousValues.some((previousValue, index) => previousValue !== currentValues[index]);
+        },
+        effect: (action, { dispatch, getState, extra }) => {
+            const selectorResults = selectors.map((selector) => selector(getState()));
+            callback({
+                dispatch,
+                getState,
+                extra,
+            }, ...selectorResults);
+        },
+    });
+};
+
+const coreVersion = "1.0.0";
+
+const initialState = {
+    isNodeSdk: false,
+    isActive: false,
+    isDialIn: false,
+    ignoreBreakoutGroups: false,
+    roomName: null,
+    roomUrl: null,
+    displayName: null,
+    userAgent: `core:${coreVersion}`,
+    externalId: null,
+};
+const appSlice = createSlice({
+    name: "app",
+    initialState,
+    reducers: {
+        doAppStart: (state, action) => {
+            const url = new URL(action.payload.roomUrl);
+            return Object.assign(Object.assign(Object.assign({}, state), action.payload), { roomName: url.pathname, initialConfig: Object.assign({}, action.payload), isActive: true });
+        },
+        doAppStop: (state) => {
+            return Object.assign(Object.assign({}, state), { isActive: false });
+        },
+    },
+});
+const { doAppStop, doAppStart } = appSlice.actions;
+const selectAppRaw = (state) => state.app;
+const selectAppIsActive = (state) => state.app.isActive;
+const selectAppIsDialIn = (state) => state.app.isDialIn;
+const selectAppRoomName = (state) => state.app.roomName;
+const selectAppRoomUrl = (state) => state.app.roomUrl;
+const selectAppDisplayName = (state) => state.app.displayName;
+const selectAppUserAgent = (state) => state.app.userAgent;
+const selectAppExternalId = (state) => state.app.externalId;
+const selectAppIsNodeSdk = (state) => state.app.isNodeSdk;
+const selectAppInitialConfig = (state) => state.app.initialConfig;
+const selectAppIgnoreBreakoutGroups = (state) => state.app.ignoreBreakoutGroups;
+
+function createSignalEventAction(name) {
+    return createAction(`signalConnection/event/${name}`);
+}
+const signalEvents = {
+    audioEnabled: createSignalEventAction("audioEnabled"),
+    audioEnableRequested: createSignalEventAction("audioEnableRequested"),
+    breakoutGroupJoined: createSignalEventAction("breakoutGroupJoined"),
+    breakoutMoveToGroup: createSignalEventAction("breakoutMoveToGroup"),
+    breakoutMoveToMain: createSignalEventAction("breakoutMoveToMain"),
+    breakoutSessionUpdated: createSignalEventAction("breakoutSessionUpdated"),
+    chatMessage: createSignalEventAction("chatMessage"),
+    clientLeft: createSignalEventAction("clientLeft"),
+    clientKicked: createSignalEventAction("clientKicked"),
+    clientMetadataReceived: createSignalEventAction("clientMetadataReceived"),
+    clientUnableToJoin: createSignalEventAction("clientUnableToJoin"),
+    cloudRecordingStarted: createSignalEventAction("cloudRecordingStarted"),
+    cloudRecordingStopped: createSignalEventAction("cloudRecordingStopped"),
+    disconnect: createSignalEventAction("disconnect"),
+    knockerLeft: createSignalEventAction("knockerLeft"),
+    knockHandled: createSignalEventAction("knockHandled"),
+    newClient: createSignalEventAction("newClient"),
+    roomJoined: createSignalEventAction("roomJoined"),
+    roomKnocked: createSignalEventAction("roomKnocked"),
+    roomLeft: createSignalEventAction("roomLeft"),
+    roomLocked: createSignalEventAction("roomLocked"),
+    roomSessionEnded: createSignalEventAction("roomSessionEnded"),
+    screenshareStarted: createSignalEventAction("screenshareStarted"),
+    screenshareStopped: createSignalEventAction("screenshareStopped"),
+    spotlightAdded: createSignalEventAction("spotlightAdded"),
+    spotlightRemoved: createSignalEventAction("spotlightRemoved"),
+    streamingStopped: createSignalEventAction("streamingStopped"),
+    videoEnabled: createSignalEventAction("videoEnabled"),
+    videoEnableRequested: createSignalEventAction("videoEnableRequested"),
+    liveTranscriptionStarted: createSignalEventAction("liveTranscriptionStarted"),
+    liveTranscriptionStopped: createSignalEventAction("liveTranscriptionStopped"),
+};
+
+const ROOM_ACTION_PERMISSIONS_BY_ROLE = {
+    canLockRoom: ["host"],
+    canRequestAudioEnable: ["host"],
+    canRequestVideoEnable: ["host"],
+    canKickClient: ["host"],
+    canEndMeeting: ["host"],
+    canAskToSpeak: ["host"],
+    canSpotlight: ["host"],
+};
+const authorizationSliceInitialState = {
+    roomKey: null,
+    roleName: "none",
+};
+const authorizationSlice = createSlice({
+    name: "authorization",
+    initialState: authorizationSliceInitialState,
+    reducers: {
+        setRoomKey: (state, action) => {
+            return Object.assign(Object.assign({}, state), { roomKey: action.payload });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppStart, (state, action) => {
+            return Object.assign(Object.assign({}, state), { roomKey: action.payload.roomKey });
+        });
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            if ("error" in action.payload) {
+                return state;
+            }
+            const { room, selfId } = action.payload || {};
+            const client = room === null || room === void 0 ? void 0 : room.clients.find((c) => c.id === selfId);
+            if (client) {
+                return Object.assign(Object.assign({}, state), { roleName: (client === null || client === void 0 ? void 0 : client.role.roleName) || "none" });
+            }
+            return state;
+        });
+    },
+});
+const { setRoomKey } = authorizationSlice.actions;
+const selectRoomKey = (state) => state.authorization.roomKey;
+const selectAuthorizationRoleName = (state) => state.authorization.roleName;
+const selectIsAuthorizedToLockRoom = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canLockRoom.includes(localParticipantRole));
+const selectIsAuthorizedToRequestAudioEnable = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canRequestAudioEnable.includes(localParticipantRole));
+const selectIsAuthorizedToRequestVideoEnable = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canRequestVideoEnable.includes(localParticipantRole));
+const selectIsAuthorizedToKickClient = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canKickClient.includes(localParticipantRole));
+const selectIsAuthorizedToEndMeeting = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canEndMeeting.includes(localParticipantRole));
+const selectIsAuthorizedToAskToSpeak = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canAskToSpeak.includes(localParticipantRole));
+const selectIsAuthorizedToSpotlight = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canSpotlight.includes(localParticipantRole));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const deviceCredentialsSliceInitialState = {
+    isFetching: false,
+    data: null,
+};
+const deviceCredentialsSlice = createSlice({
+    name: "deviceCredentials",
+    initialState: deviceCredentialsSliceInitialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(doGetDeviceCredentials.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+        builder.addCase(doGetDeviceCredentials.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        });
+        builder.addCase(doGetDeviceCredentials.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+    },
+});
+const doGetDeviceCredentials = createAppAsyncThunk("deviceCredentials/doGetDeviceCredentials", (payload_1, _a) => __awaiter(void 0, [payload_1, _a], void 0, function* (payload, { extra }) {
+    try {
+        const deviceCredentials = yield extra.services.credentialsService.getCredentials();
+        return deviceCredentials;
+    }
+    catch (error) {
+        console.error(error);
+    }
+}));
+const selectDeviceCredentialsRaw = (state) => state.deviceCredentials;
+const selectHasFetchedDeviceCredentials = (state) => { var _a; return !!((_a = state.deviceCredentials.data) === null || _a === void 0 ? void 0 : _a.credentials); };
+const selectDeviceId = (state) => { var _a, _b; return (_b = (_a = state.deviceCredentials.data) === null || _a === void 0 ? void 0 : _a.credentials) === null || _b === void 0 ? void 0 : _b.uuid; };
+const selectShouldFetchDeviceCredentials = createSelector(selectAppIsActive, selectDeviceCredentialsRaw, (appIsActive, deviceCredentials) => {
+    if (appIsActive && !deviceCredentials.isFetching && !deviceCredentials.data) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldFetchDeviceCredentials], ({ dispatch }, shouldFetchDeviceCredentials) => {
+    if (shouldFetchDeviceCredentials) {
+        dispatch(doGetDeviceCredentials());
+    }
+});
+
+function forwardSocketEvents(socket, dispatch) {
+    socket.on("room_joined", (payload) => dispatch(signalEvents.roomJoined(payload)));
+    socket.on("new_client", (payload) => dispatch(signalEvents.newClient(payload)));
+    socket.on("client_left", (payload) => dispatch(signalEvents.clientLeft(payload)));
+    socket.on("client_kicked", (payload) => dispatch(signalEvents.clientKicked(payload)));
+    socket.on("client_unable_to_join", (payload) => dispatch(signalEvents.clientUnableToJoin(payload)));
+    socket.on("audio_enabled", (payload) => dispatch(signalEvents.audioEnabled(payload)));
+    socket.on("video_enabled", (payload) => dispatch(signalEvents.videoEnabled(payload)));
+    socket.on("audio_enable_requested", (payload) => dispatch(signalEvents.audioEnableRequested(payload)));
+    socket.on("client_metadata_received", (payload) => dispatch(signalEvents.clientMetadataReceived(payload)));
+    socket.on("chat_message", (payload) => dispatch(signalEvents.chatMessage(payload)));
+    socket.on("disconnect", () => dispatch(signalEvents.disconnect()));
+    socket.on("room_knocked", (payload) => dispatch(signalEvents.roomKnocked(payload)));
+    socket.on("room_left", () => dispatch(signalEvents.roomLeft()));
+    socket.on("room_locked", (payload) => dispatch(signalEvents.roomLocked(payload)));
+    socket.on("room_session_ended", (payload) => dispatch(signalEvents.roomSessionEnded(payload)));
+    socket.on("knocker_left", (payload) => dispatch(signalEvents.knockerLeft(payload)));
+    socket.on("knock_handled", (payload) => dispatch(signalEvents.knockHandled(payload)));
+    socket.on("screenshare_started", (payload) => dispatch(signalEvents.screenshareStarted(payload)));
+    socket.on("screenshare_stopped", (payload) => dispatch(signalEvents.screenshareStopped(payload)));
+    socket.on("cloud_recording_started", (payload) => dispatch(signalEvents.cloudRecordingStarted(payload)));
+    socket.on("cloud_recording_stopped", () => dispatch(signalEvents.cloudRecordingStopped()));
+    socket.on("streaming_stopped", () => dispatch(signalEvents.streamingStopped()));
+    socket.on("spotlight_added", (payload) => dispatch(signalEvents.spotlightAdded(payload)));
+    socket.on("spotlight_removed", (payload) => dispatch(signalEvents.spotlightRemoved(payload)));
+    socket.on("live_transcription_started", (payload) => dispatch(signalEvents.liveTranscriptionStarted(payload)));
+    socket.on("live_transcription_stopped", (payload) => dispatch(signalEvents.liveTranscriptionStopped(payload)));
+    socket.on("video_enable_requested", (payload) => dispatch(signalEvents.videoEnableRequested(payload)));
+    socket.on("breakout_group_joined", (payload) => dispatch(signalEvents.breakoutGroupJoined(payload)));
+    socket.on("breakout_session_updated", (payload) => dispatch(signalEvents.breakoutSessionUpdated(payload)));
+    socket.on("breakout_move_to_group", () => dispatch(signalEvents.breakoutMoveToGroup()));
+    socket.on("breakout_move_to_main", () => dispatch(signalEvents.breakoutMoveToMain()));
+}
+const SIGNAL_BASE_URL = "wss://signal.appearin.net";
+function createSocket() {
+    const parsedUrl = new URL(SIGNAL_BASE_URL);
+    const socketHost = parsedUrl.origin;
+    const socketOverrides = {
+        autoConnect: false,
+    };
+    return new ServerSocket(socketHost, socketOverrides);
+}
+const signalConnectionSliceInitialState = {
+    deviceIdentified: false,
+    isIdentifyingDevice: false,
+    status: "ready",
+    socket: null,
+};
+const signalConnectionSlice = createSlice({
+    name: "signalConnection",
+    initialState: signalConnectionSliceInitialState,
+    reducers: {
+        socketConnecting: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "connecting" });
+        },
+        socketConnected: (state, action) => {
+            return Object.assign(Object.assign({}, state), { socket: action.payload, status: "connected" });
+        },
+        socketDisconnected: (state) => {
+            return Object.assign(Object.assign({}, state), { socket: null, deviceIdentified: false, status: "disconnected" });
+        },
+        socketReconnecting: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
+        },
+        deviceIdentifying: (state) => {
+            return Object.assign(Object.assign({}, state), { isIdentifyingDevice: true });
+        },
+        deviceIdentified: (state) => {
+            return Object.assign(Object.assign({}, state), { deviceIdentified: true, isIdentifyingDevice: false });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.disconnect, (state) => {
+            return Object.assign(Object.assign({}, state), { deviceIdentified: false, status: "disconnected" });
+        });
+    },
+});
+const { deviceIdentifying, deviceIdentified, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, } = signalConnectionSlice.actions;
+const doSignalConnect = createAppThunk(() => {
+    return (dispatch, getState) => {
+        if (selectSignalConnectionSocket(getState())) {
+            return;
+        }
+        dispatch(socketConnecting());
+        const socket = createSocket();
+        socket.on("connect", () => dispatch(socketConnected(socket)));
+        socket.on("device_identified", () => dispatch(deviceIdentified()));
+        socket.getManager().on("reconnect", () => dispatch(socketReconnecting()));
+        forwardSocketEvents(socket, dispatch);
+        socket.connect();
+    };
+});
+const doSignalIdentifyDevice = createAppThunk(({ deviceCredentials }) => (dispatch, getState) => {
+    const state = getState();
+    const signalSocket = selectSignalConnectionSocket(state);
+    const deviceIdentified = selectSignalConnectionDeviceIdentified(state);
+    if (!signalSocket) {
+        return;
+    }
+    if (deviceIdentified) {
+        return;
+    }
+    signalSocket.emit("identify_device", { deviceCredentials });
+    dispatch(deviceIdentifying());
+});
+const doSignalDisconnect = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const signalStatus = selectSignalStatus(state);
+    if (signalStatus === "connected") {
+        const socket = selectSignalConnectionRaw(state).socket;
+        socket === null || socket === void 0 ? void 0 : socket.disconnect();
+        dispatch(socketDisconnected());
+    }
+});
+const selectSignalConnectionRaw = (state) => state.signalConnection;
+const selectSignalIsIdentifyingDevice = (state) => state.signalConnection.isIdentifyingDevice;
+const selectSignalConnectionDeviceIdentified = (state) => state.signalConnection.deviceIdentified;
+const selectSignalStatus = (state) => state.signalConnection.status;
+const selectSignalConnectionSocket = (state) => state.signalConnection.socket;
+const selectShouldConnectSignal = createSelector(selectAppIsActive, selectSignalStatus, (appIsActive, signalStatus) => {
+    if (appIsActive && ["ready", "reconnecting"].includes(signalStatus)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectSignal], ({ dispatch }, shouldConnectSignal) => {
+    if (shouldConnectSignal) {
+        dispatch(doSignalConnect());
+    }
+});
+const selectShouldIdentifyDevice = createSelector(selectDeviceCredentialsRaw, selectSignalStatus, selectSignalConnectionDeviceIdentified, selectSignalIsIdentifyingDevice, (deviceCredentialsRaw, signalStatus, deviceIdentified, isIdentifyingDevice) => {
+    if (deviceCredentialsRaw.data && signalStatus === "connected" && !deviceIdentified && !isIdentifyingDevice) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldIdentifyDevice, selectDeviceCredentialsRaw], ({ dispatch }, shouldIdentifyDevice, deviceCredentialsRaw) => {
+    if (shouldIdentifyDevice && deviceCredentialsRaw.data) {
+        dispatch(doSignalIdentifyDevice({ deviceCredentials: deviceCredentialsRaw.data }));
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.roomLeft,
+    effect: (_, { dispatch }) => {
+        dispatch(doSignalDisconnect());
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.clientKicked,
+    effect: (_, { dispatch }) => {
+        dispatch(doSignalDisconnect());
+    },
+});
+
+function debounce(fn, { delay = 500, edges } = {}) {
+    let timeout;
+    let nCalls = 0;
+    return (...args) => {
+        nCalls += 1;
+        if (edges && nCalls === 1) {
+            fn(...args);
+        }
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            if (!edges || nCalls > 1) {
+                fn(...args);
+            }
+            timeout = undefined;
+            nCalls = 0;
+        }, delay);
+    };
+}
+
+const initialLocalMediaState = {
+    busyDeviceIds: [],
+    cameraEnabled: false,
+    currentSpeakerDeviceId: "default",
+    devices: [],
+    isSettingCameraDevice: false,
+    isSettingMicrophoneDevice: false,
+    isSettingSpeakerDevice: false,
+    isTogglingCamera: false,
+    lowDataMode: false,
+    microphoneEnabled: false,
+    status: "inactive",
+    stream: undefined,
+    isSwitchingStream: false,
+};
+const localMediaSlice = createSlice({
+    name: "localMedia",
+    initialState: initialLocalMediaState,
+    reducers: {
+        deviceBusy(state, action) {
+            if (state.busyDeviceIds.includes(action.payload.deviceId)) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { busyDeviceIds: [...state.busyDeviceIds, action.payload.deviceId] });
+        },
+        toggleCameraEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { cameraEnabled: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.cameraEnabled });
+        },
+        setCurrentCameraDeviceId(state, action) {
+            return Object.assign(Object.assign({}, state), { currentCameraDeviceId: action.payload.deviceId });
+        },
+        toggleMicrophoneEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { microphoneEnabled: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.microphoneEnabled });
+        },
+        setCurrentMicrophoneDeviceId(state, action) {
+            return Object.assign(Object.assign({}, state), { currentMicrophoneDeviceId: action.payload.deviceId });
+        },
+        setCurrentSpeakerDeviceId(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { currentSpeakerDeviceId: (_a = action.payload.deviceId) !== null && _a !== void 0 ? _a : "default" });
+        },
+        toggleLowDataModeEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { lowDataMode: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.lowDataMode });
+        },
+        setDevices(state, action) {
+            return Object.assign(Object.assign({}, state), { devices: action.payload.devices });
+        },
+        setLocalMediaStream(state, action) {
+            return Object.assign(Object.assign({}, state), { stream: action.payload.stream });
+        },
+        setLocalMediaOptions(state, action) {
+            return Object.assign(Object.assign({}, state), { options: action.payload.options });
+        },
+        localMediaStopped(state) {
+            return Object.assign(Object.assign({}, state), { status: "stopped", stream: undefined });
+        },
+        localStreamMetadataUpdated(state, action) {
+            const { audio, video } = action.payload;
+            return Object.assign(Object.assign({}, state), { currentCameraDeviceId: video.deviceId, currentMicrophoneDeviceId: audio.deviceId, busyDeviceIds: state.busyDeviceIds.filter((id) => id !== audio.deviceId && id !== video.deviceId) });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppStart, (state, action) => {
+            return Object.assign(Object.assign({}, state), { options: action.payload.localMediaOptions });
+        });
+        builder.addCase(doSetDevice.pending, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video, isSettingMicrophoneDevice: audio });
+        });
+        builder.addCase(doSetDevice.fulfilled, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video ? false : state.isSettingCameraDevice, isSettingMicrophoneDevice: audio ? false : state.isSettingMicrophoneDevice });
+        });
+        builder.addCase(doSetDevice.rejected, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video ? false : state.isSettingCameraDevice, isSettingMicrophoneDevice: audio ? false : state.isSettingMicrophoneDevice, cameraDeviceError: video ? action.error : state.cameraDeviceError, microphoneDeviceError: audio ? action.error : state.microphoneDeviceError });
+        });
+        builder.addCase(doToggleCamera.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isTogglingCamera: true });
+        });
+        builder.addCase(doToggleCamera.fulfilled, (state) => {
+            return Object.assign(Object.assign({}, state), { isTogglingCamera: false });
+        });
+        builder.addCase(doUpdateDeviceList.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { devices: action.payload.devices });
+        });
+        builder.addCase(doStartLocalMedia.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "starting" });
+        });
+        builder.addCase(doStartLocalMedia.fulfilled, (state, { payload: { stream, onDeviceChange } }) => {
+            let cameraDeviceId = undefined;
+            let cameraEnabled = false;
+            let microphoneDeviceId = undefined;
+            let microphoneEnabled = false;
+            const audioTrack = stream.getAudioTracks()[0];
+            const videoTrack = stream.getVideoTracks()[0];
+            if (audioTrack) {
+                microphoneDeviceId = audioTrack.getSettings().deviceId;
+                microphoneEnabled = audioTrack.enabled;
+            }
+            if (videoTrack) {
+                cameraEnabled = videoTrack.enabled;
+                cameraDeviceId = videoTrack.getSettings().deviceId;
+            }
+            return Object.assign(Object.assign({}, state), { stream, status: "started", currentCameraDeviceId: cameraDeviceId, currentMicrophoneDeviceId: microphoneDeviceId, cameraEnabled,
+                microphoneEnabled,
+                onDeviceChange });
+        });
+        builder.addCase(doStartLocalMedia.rejected, (state, action) => {
+            return Object.assign(Object.assign({}, state), { status: "error", startError: action.error });
+        });
+        builder.addCase(doSwitchLocalStream.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: true });
+        });
+        builder.addCase(doSwitchLocalStream.fulfilled, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: false });
+        });
+        builder.addCase(doSwitchLocalStream.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: false });
+        });
+    },
+});
+const { deviceBusy, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setCurrentSpeakerDeviceId, toggleCameraEnabled, toggleMicrophoneEnabled, toggleLowDataModeEnabled, setLocalMediaOptions, setLocalMediaStream, localMediaStopped, localStreamMetadataUpdated, } = localMediaSlice.actions;
+const doToggleCamera = createAppAsyncThunk("localMedia/doToggleCamera", (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { getState, rejectWithValue }) {
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    let track = stream.getVideoTracks()[0];
+    const enabled = selectIsCameraEnabled(state);
+    try {
+        if (enabled) {
+            if (track) {
+                track.enabled = true;
+            }
+            else {
+                const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+                const cameraDeviceId = selectCurrentCameraDeviceId(state);
+                yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: false, videoId: cameraDeviceId, type: "exact" }), { replaceStream: stream });
+                track = stream.getVideoTracks()[0];
+            }
+        }
+        else {
+            if (!track) {
+                return;
+            }
+            track.enabled = false;
+            track.stop();
+            stream.removeTrack(track);
+        }
+        stream.dispatchEvent(new CustomEvent("stopresumevideo", { detail: { track, enable: enabled } }));
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doToggleMicrophone = createAppAsyncThunk("localMedia/doToggleMicrophone", (_, { getState }) => {
+    var _a;
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    const enabled = selectIsMicrophoneEnabled(state);
+    const audioTrack = (_a = stream.getAudioTracks()) === null || _a === void 0 ? void 0 : _a[0];
+    if (!audioTrack) {
+        return;
+    }
+    audioTrack.enabled = enabled;
+});
+const doToggleLowDataMode = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    const videoId = selectCurrentCameraDeviceId(state);
+    const audioId = selectCurrentMicrophoneDeviceId(state);
+    dispatch(doSwitchLocalStream({ audioId, videoId }));
+});
+const doSetDevice = createAppAsyncThunk("localMedia/reactSetDevice", (_a, _b) => __awaiter(void 0, [_a, _b], void 0, function* ({ audio, video }, { getState, rejectWithValue }) {
+    try {
+        const state = getState();
+        const stream = selectLocalMediaStream(state);
+        if (!stream) {
+            throw new Error("No stream");
+        }
+        const audioId = audio ? selectCurrentMicrophoneDeviceId(state) : false;
+        const videoId = video ? selectCurrentCameraDeviceId(state) : false;
+        const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+        const { replacedTracks } = yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId,
+            videoId, type: "exact" }), { replaceStream: stream });
+        const isAudioEnabled = selectIsMicrophoneEnabled(state);
+        stream.getAudioTracks().forEach((track) => (track.enabled = isAudioEnabled));
+        const isVideoEnabled = selectIsCameraEnabled(state);
+        stream.getVideoTracks().forEach((track) => (track.enabled = isVideoEnabled));
+        return { replacedTracks };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doUpdateDeviceList = createAppAsyncThunk("localMedia/doUpdateDeviceList", (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { getState, dispatch, rejectWithValue }) {
+    var _b, _c, _d, _e;
+    const state = getState();
+    let newDevices = [];
+    let oldDevices = [];
+    const stream = selectLocalMediaStream(state);
+    try {
+        newDevices = yield navigator.mediaDevices.enumerateDevices();
+        oldDevices = selectLocalMediaDevices(state);
+        const shouldHandleDeviceUpdate = stream &&
+            !selectLocalMediaIsSwitchingStream(state) &&
+            newDevices &&
+            oldDevices &&
+            oldDevices.find((d) => d.deviceId);
+        if (!shouldHandleDeviceUpdate) {
+            return { devices: newDevices };
+        }
+        const { changedDevices, addedDevices } = getUpdatedDevices({
+            oldDevices,
+            newDevices,
+        });
+        let autoSwitchAudioId = (_b = changedDevices.audioinput) === null || _b === void 0 ? void 0 : _b.deviceId;
+        let autoSwitchVideoId = (_c = changedDevices.videoinput) === null || _c === void 0 ? void 0 : _c.deviceId;
+        if (autoSwitchAudioId === undefined) {
+            autoSwitchAudioId = (_d = addedDevices.audioinput) === null || _d === void 0 ? void 0 : _d.deviceId;
+        }
+        if (autoSwitchVideoId === undefined) {
+            autoSwitchVideoId = (_e = addedDevices.videoinput) === null || _e === void 0 ? void 0 : _e.deviceId;
+        }
+        if (autoSwitchAudioId !== undefined || autoSwitchVideoId !== undefined) {
+            dispatch(doSwitchLocalStream({ audioId: autoSwitchAudioId, videoId: autoSwitchVideoId }));
+        }
+        return { devices: newDevices };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doSwitchLocalStream = createAppAsyncThunk("localMedia/doSwitchLocalStream", (_a, _b) => __awaiter(void 0, [_a, _b], void 0, function* ({ audioId, videoId }, { dispatch, getState, rejectWithValue }) {
+    const state = getState();
+    const replaceStream = selectLocalMediaStream(state);
+    const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+    const onlySwitchingOne = !!(videoId && !audioId) || !!(!videoId && audioId);
+    if (!replaceStream) {
+        return;
+    }
+    try {
+        const { replacedTracks } = yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: audioId === undefined ? false : audioId, videoId: videoId === undefined ? false : videoId, type: "exact" }), { replaceStream });
+        const deviceId = audioId || videoId;
+        if (onlySwitchingOne && deviceId) {
+            dispatch(deviceBusy({
+                deviceId,
+            }));
+        }
+        return { replacedTracks };
+    }
+    catch (error) {
+        console.error(error);
+        const deviceId = audioId || videoId;
+        if (onlySwitchingOne && deviceId) {
+            dispatch(deviceBusy({
+                deviceId,
+            }));
+        }
+        return rejectWithValue(error);
+    }
+}));
+const doStartLocalMedia = createAppAsyncThunk("localMedia/doStartLocalMedia", (payload_1, _a) => __awaiter(void 0, [payload_1, _a], void 0, function* (payload, { getState, dispatch, rejectWithValue }) {
+    const onDeviceChange = debounce(() => {
+        dispatch(doUpdateDeviceList());
+    }, { delay: 500 });
+    if (navigator.mediaDevices) {
+        navigator.mediaDevices.addEventListener("devicechange", onDeviceChange);
+    }
+    if ("getTracks" in payload) {
+        return Promise.resolve({ stream: payload, onDeviceChange });
+    }
+    if (!(payload.audio || payload.video)) {
+        return { stream: new MediaStream(), onDeviceChange };
+    }
+    else {
+        dispatch(setLocalMediaOptions({ options: payload }));
+    }
+    try {
+        yield dispatch(doUpdateDeviceList());
+        const state = getState();
+        const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+        const { stream } = yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: payload.audio, videoId: payload.video }));
+        return { stream, onDeviceChange };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doStopLocalMedia = createAppThunk(() => (dispatch, getState) => {
+    const stream = selectLocalMediaStream(getState());
+    const onDeviceChange = selectLocalMediaRaw(getState()).onDeviceChange;
+    stream === null || stream === void 0 ? void 0 : stream.getTracks().forEach((track) => {
+        track.stop();
+    });
+    if (navigator.mediaDevices && onDeviceChange) {
+        navigator.mediaDevices.removeEventListener("devicechange", onDeviceChange);
+    }
+    dispatch(localMediaStopped());
+});
+const selectBusyDeviceIds = (state) => state.localMedia.busyDeviceIds;
+const selectCameraDeviceError = (state) => state.localMedia.cameraDeviceError;
+const selectCurrentCameraDeviceId = (state) => state.localMedia.currentCameraDeviceId;
+const selectCurrentMicrophoneDeviceId = (state) => state.localMedia.currentMicrophoneDeviceId;
+const selectCurrentSpeakerDeviceId = (state) => state.localMedia.currentSpeakerDeviceId;
+const selectIsCameraEnabled = (state) => state.localMedia.cameraEnabled;
+const selectIsMicrophoneEnabled = (state) => state.localMedia.microphoneEnabled;
+const selectIsLowDataModeEnabled = (state) => state.localMedia.lowDataMode;
+const selectIsSettingCameraDevice = (state) => state.localMedia.isSettingCameraDevice;
+const selectIsSettingMicrophoneDevice = (state) => state.localMedia.isSettingMicrophoneDevice;
+const selectIsToggleCamera = (state) => state.localMedia.isTogglingCamera;
+const selectLocalMediaDevices = (state) => state.localMedia.devices;
+const selectLocalMediaOptions = (state) => state.localMedia.options;
+const selectLocalMediaOwnsStream = createSelector(selectLocalMediaOptions, (options) => !!options);
+const selectLocalMediaRaw = (state) => state.localMedia;
+const selectLocalMediaStatus = (state) => state.localMedia.status;
+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 selectLocalMediaConstraintsOptions = createSelector(selectLocalMediaDevices, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectIsLowDataModeEnabled, (devices, videoId, audioId, lowDataMode) => ({
+    devices,
+    videoId,
+    audioId,
+    options: {
+        disableAEC: false,
+        disableAGC: false,
+        hd: true,
+        lax: false,
+        lowDataMode,
+        simulcast: true,
+        widescreen: true,
+    },
+}));
+const selectIsLocalMediaStarting = createSelector(selectLocalMediaStatus, (status) => status === "starting");
+const selectCameraDevices = createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "videoinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
+const selectMicrophoneDevices = createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "audioinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
+const selectSpeakerDevices = createSelector(selectLocalMediaDevices, (devices) => devices.filter((d) => d.kind === "audiooutput"));
+const selectLocalMediaShouldStartWithOptions = createSelector(selectAppIsActive, selectLocalMediaStatus, selectLocalMediaOptions, (appIsActive, localMediaStatus, localMediaOptions) => {
+    if (appIsActive && ["inactive", "stopped"].includes(localMediaStatus) && localMediaOptions) {
+        return localMediaOptions;
+    }
+});
+createReactor([selectLocalMediaShouldStartWithOptions], ({ dispatch }, options) => {
+    if (options) {
+        dispatch(doStartLocalMedia(options));
+    }
+});
+const selectLocalMediaShouldStop = createSelector(selectAppIsActive, selectLocalMediaStatus, selectLocalMediaOptions, (appIsActive, localMediaStatus, localMediaOptions) => {
+    return !appIsActive && localMediaStatus !== "inactive" && !!localMediaOptions;
+});
+createReactor([selectLocalMediaShouldStop], ({ dispatch }, localMediaShouldStop) => {
+    if (localMediaShouldStop) {
+        dispatch(doStopLocalMedia());
+    }
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectIsMicrophoneEnabled(previousState);
+        const newValue = selectIsMicrophoneEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_, { dispatch }) => {
+        dispatch(doToggleMicrophone());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectIsLowDataModeEnabled(previousState);
+        const newValue = selectIsLowDataModeEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doToggleLowDataMode());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const isToggling = selectIsToggleCamera(currentState);
+        if (isToggling) {
+            return false;
+        }
+        const oldValue = selectIsCameraEnabled(previousState);
+        const newValue = selectIsCameraEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doToggleCamera());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectCurrentCameraDeviceId(previousState);
+        const newValue = selectCurrentCameraDeviceId(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doSetDevice({ audio: false, video: true }));
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectCurrentMicrophoneDeviceId(previousState);
+        const newValue = selectCurrentMicrophoneDeviceId(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doSetDevice({ audio: true, video: false }));
+    },
+});
+startAppListening({
+    matcher: isAnyOf(doStartLocalMedia.fulfilled, doUpdateDeviceList.fulfilled, doSwitchLocalStream.fulfilled, doSwitchLocalStream.rejected),
+    effect: (_action, { dispatch, getState }) => {
+        const state = getState();
+        const stream = selectLocalMediaStream(state);
+        const devices = selectLocalMediaDevices(state);
+        if (!stream)
+            return;
+        const deviceData = getDeviceData({
+            audioTrack: stream.getAudioTracks()[0],
+            videoTrack: stream.getVideoTracks()[0],
+            devices,
+        });
+        dispatch(localStreamMetadataUpdated(deviceData));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.audioEnableRequested,
+    effect: ({ payload }, { dispatch }) => {
+        const { enable } = payload;
+        if (!enable) {
+            dispatch(toggleMicrophoneEnabled({ enabled: false }));
+        }
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.videoEnableRequested,
+    effect: ({ payload }, { dispatch }) => {
+        const { enable } = payload;
+        if (!enable) {
+            dispatch(toggleCameraEnabled({ enabled: false }));
+        }
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.breakoutSessionUpdated,
+    effect: ({ payload }, { dispatch }) => {
+        var _a;
+        if (((_a = payload.initiatedBy) === null || _a === void 0 ? void 0 : _a.active) === false) {
+            dispatch(toggleMicrophoneEnabled({ enabled: false }));
+        }
+    },
+});
+
+const NON_PERSON_ROLES = ["recorder", "streamer"];
+
+const selectLocalParticipantRaw = (state) => state.localParticipant;
+const selectSelfId = (state) => state.localParticipant.id;
+const selectLocalParticipantDisplayName = (state) => state.localParticipant.displayName;
+const selectLocalParticipantClientClaim = (state) => state.localParticipant.clientClaim;
+const selectLocalParticipantIsScreenSharing = (state) => state.localParticipant.isScreenSharing;
+const selectLocalParticipantStickyReaction = (state) => state.localParticipant.stickyReaction;
+const selectLocalParticipantBreakoutGroup = (state) => state.localParticipant.breakoutGroup;
+const selectLocalParticipantBreakoutAssigned = (state) => state.localParticipant.breakoutGroupAssigned;
+const selectLocalParticipantView = createSelector(selectLocalParticipantRaw, selectLocalMediaStream, (participant, localStream) => {
+    const clientView = {
+        id: participant.id,
+        clientId: participant.id,
+        breakoutGroup: participant.breakoutGroup,
+        displayName: participant.displayName,
+        stream: localStream,
+        isLocalClient: true,
+        isAudioEnabled: participant.isAudioEnabled,
+        isVideoEnabled: participant.isVideoEnabled,
+    };
+    if (NON_PERSON_ROLES.includes(participant.roleName)) {
+        return null;
+    }
+    return clientView;
+});
+
+function createBreakout({ assignments, groups, startedAt, initiatedBy, breakoutStartedAt, breakoutEndedAt, breakoutNotification, breakoutTimerDuration, autoMoveToGroup, moveToGroupGracePeriod, autoMoveToMain, moveToMainGracePeriod, enforceAssignment, breakoutTimerSetting, } = {}) {
+    return {
+        assignments: assignments || null,
+        groups: groups || null,
+        startedAt: startedAt ? new Date(startedAt) : null,
+        initiatedBy,
+        breakoutStartedAt: breakoutStartedAt || null,
+        breakoutEndedAt: breakoutEndedAt || null,
+        breakoutNotification: breakoutNotification || null,
+        breakoutTimerDuration: breakoutTimerDuration || 1800,
+        autoMoveToGroup: autoMoveToGroup || false,
+        moveToGroupGracePeriod: moveToGroupGracePeriod || 10,
+        autoMoveToMain: autoMoveToMain || false,
+        moveToMainGracePeriod: moveToMainGracePeriod || 30,
+        enforceAssignment: enforceAssignment || false,
+        breakoutTimerSetting: breakoutTimerSetting || false,
+    };
+}
+const breakoutSliceInitialState = Object.assign(Object.assign({}, createBreakout()), { groupId: null });
+const breakoutSlice = createSlice({
+    name: "breakout",
+    initialState: breakoutSliceInitialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            if ("error" in action.payload) {
+                return state;
+            }
+            const { breakout } = action.payload || {};
+            if (breakout) {
+                return Object.assign(Object.assign({}, state), createBreakout(breakout));
+            }
+            return state;
+        });
+        builder.addCase(signalEvents.breakoutSessionUpdated, (state, action) => {
+            return Object.assign(Object.assign({}, state), createBreakout(action.payload));
+        });
+        builder.addCase(signalEvents.breakoutGroupJoined, (state, action) => {
+            var _a;
+            if (((_a = action.meta) === null || _a === void 0 ? void 0 : _a.localParticipantId) !== action.payload.clientId) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { groupId: action.payload.group });
+        });
+    },
+});
+const doBreakoutJoin = createAppThunk((payload) => (_, getState) => {
+    const state = getState();
+    const { socket } = selectSignalConnectionRaw(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("join_breakout_group", { group: payload.group });
+});
+const selectBreakoutRaw = (state) => state.breakout;
+const selectBreakoutInitiatedBy = (state) => state.breakout.initiatedBy;
+const selectBreakoutActive = (state) => !!state.breakout.startedAt;
+const selectBreakoutAssignments = (state) => state.breakout.assignments;
+const selectBreakoutGroups = (state) => state.breakout.groups;
+const selectBreakoutCurrentId = createSelector(selectBreakoutRaw, selectLocalParticipantBreakoutGroup, (raw, localParticipantBreakoutGroup) => {
+    return raw.groupId || localParticipantBreakoutGroup || "";
+});
+const selectBreakoutCurrentGroup = createSelector(selectBreakoutRaw, selectBreakoutCurrentId, (raw, breakoutCurrentId) => {
+    var _a;
+    const name = (_a = raw.groups) === null || _a === void 0 ? void 0 : _a[breakoutCurrentId];
+    if (!name)
+        return null;
+    return { id: breakoutCurrentId, name };
+});
+startAppListening({
+    actionCreator: signalEvents.breakoutMoveToGroup,
+    effect: (_, { dispatch, getState }) => {
+        const state = getState();
+        const localParticipant = selectLocalParticipantRaw(state);
+        const breakoutGroupAssigned = localParticipant.breakoutGroupAssigned;
+        if (breakoutGroupAssigned) {
+            dispatch(doBreakoutJoin({ group: breakoutGroupAssigned }));
+        }
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.breakoutMoveToMain,
+    effect: (_, { dispatch }) => {
+        dispatch(doBreakoutJoin({ group: "" }));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.breakoutSessionUpdated,
+    effect: ({ payload }, { dispatch, getState }) => {
+        var _a;
+        const state = getState();
+        const autoMoveToMain = selectBreakoutRaw(state).autoMoveToMain;
+        if (((_a = payload.initiatedBy) === null || _a === void 0 ? void 0 : _a.active) === false) {
+            if (!autoMoveToMain) {
+                dispatch(doBreakoutJoin({ group: "" }));
+            }
+        }
+    },
+});
+
+const chatSliceInitialState = {
+    chatMessages: [],
+};
+const chatSlice = createSlice({
+    name: "chat",
+    initialState: chatSliceInitialState,
+    reducers: {},
+    extraReducers(builder) {
+        builder.addCase(signalEvents.chatMessage, (state, action) => {
+            const message = {
+                senderId: action.payload.senderId,
+                timestamp: action.payload.timestamp,
+                text: action.payload.text,
+            };
+            return Object.assign(Object.assign({}, state), { chatMessages: [...state.chatMessages, message] });
+        });
+    },
+});
+const doSendChatMessage = createRoomConnectedThunk((payload) => (_, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const breakoutCurrentId = selectBreakoutCurrentId(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("chat_message", Object.assign(Object.assign({ text: payload.text }, (breakoutCurrentId && { breakoutGroup: breakoutCurrentId })), (payload.isBroadcast && { broadcast: true })));
+});
+const selectChatRaw = (state) => state.chat;
+const selectChatMessages = (state) => state.chat.chatMessages;
+
+const initialCloudRecordingState = {
+    isRecording: false,
+    error: null,
+    startedAt: undefined,
+};
+const cloudRecordingSlice = createSlice({
+    name: "cloudRecording",
+    initialState: initialCloudRecordingState,
+    reducers: {
+        recordingRequestStarted: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "requested" });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.cloudRecordingStopped, (state) => {
+            return Object.assign(Object.assign({}, state), { isRecording: false, status: undefined });
+        });
+        builder.addCase(signalEvents.cloudRecordingStarted, (state, action) => {
+            const { payload } = action;
+            if (!payload.error) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { isRecording: false, status: "error", error: payload.error });
+        });
+        builder.addCase(signalEvents.newClient, (state, { payload }) => {
+            var _a;
+            const { client } = payload;
+            if (((_a = client.role) === null || _a === void 0 ? void 0 : _a.roleName) === "recorder") {
+                return Object.assign(Object.assign({}, state), { isRecording: true, status: "recording", startedAt: client.startedCloudRecordingAt
+                        ? new Date(client.startedCloudRecordingAt).getTime()
+                        : new Date().getTime() });
+            }
+            return state;
+        });
+    },
+});
+const { recordingRequestStarted } = cloudRecordingSlice.actions;
+const doStartCloudRecording = createRoomConnectedThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const status = selectCloudRecordingStatus(state);
+    if (status && ["recording", "requested"].includes(status)) {
+        return;
+    }
+    socket === null || socket === void 0 ? void 0 : socket.emit("start_recording", {
+        recording: "cloud",
+    });
+    dispatch(recordingRequestStarted());
+});
+const doStopCloudRecording = createRoomConnectedThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("stop_recording");
+});
+const selectCloudRecordingRaw = (state) => state.cloudRecording;
+const selectCloudRecordingStatus = (state) => state.cloudRecording.status;
+const selectCloudRecordingStartedAt = (state) => state.cloudRecording.startedAt;
+const selectCloudRecordingError = (state) => state.cloudRecording.error;
+const selectIsCloudRecording = (state) => state.cloudRecording.isRecording;
+
+const selectRoomConnectionRaw = (state) => state.roomConnection;
+const selectRoomConnectionSession = (state) => state.roomConnection.session;
+const selectRoomConnectionSessionId = (state) => { var _a; return (_a = state.roomConnection.session) === null || _a === void 0 ? void 0 : _a.id; };
+const selectRoomConnectionStatus = (state) => state.roomConnection.status;
+const selectRoomConnectionError = (state) => state.roomConnection.error;
+
+function createRtcEventAction(name) {
+    return createAction(`rtcConnection/event/${name}`);
+}
+const rtcEvents = {
+    rtcManagerCreated: createRtcEventAction("rtcManagerCreated"),
+    rtcManagerDestroyed: createRtcEventAction("rtcManagerDestroyed"),
+    streamAdded: createRtcEventAction("streamAdded"),
+    clientConnectionStatusChanged: createRtcEventAction("clientConnectionStatusChanged"),
+};
+
+function createRemoteParticipant(client, newJoiner = false) {
+    const { streams, role, breakoutGroup } = client, rest = __rest(client, ["streams", "role", "breakoutGroup"]);
+    return Object.assign(Object.assign({}, rest), { stream: null, streams: streams.map((streamId) => ({ id: streamId, state: newJoiner ? "new_accept" : "to_accept" })), isLocalParticipant: false, roleName: (role === null || role === void 0 ? void 0 : role.roleName) || "none", presentationStream: null, breakoutGroup: breakoutGroup || null, newJoiner });
+}
+function findParticipant(state, participantId) {
+    const index = state.remoteParticipants.findIndex((c) => c.id === participantId);
+    return { index, participant: state.remoteParticipants[index] };
+}
+function updateParticipant(state, participantId, updates) {
+    const { participant, index } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`Did not find client for update ${participantId}`);
+        return state;
+    }
+    return Object.assign(Object.assign({}, state), { remoteParticipants: [
+            ...state.remoteParticipants.slice(0, index),
+            Object.assign(Object.assign({}, participant), updates),
+            ...state.remoteParticipants.slice(index + 1),
+        ] });
+}
+function addParticipant(state, participant) {
+    const { participant: foundParticipant } = findParticipant(state, participant.id);
+    if (foundParticipant) {
+        console.warn(`Client already existing ${participant.id}. Ignoring`);
+        return state;
+    }
+    return Object.assign(Object.assign({}, state), { remoteParticipants: [...state.remoteParticipants, participant] });
+}
+function updateStreamState(state, participantId, streamId, state_) {
+    const { participant } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`No client ${participantId} found to update stream ${streamId} ${state_}`);
+        return state;
+    }
+    const idIdx = participant.streams.findIndex((s) => s.id === streamId);
+    const streams = [...participant.streams];
+    streams[idIdx] = Object.assign(Object.assign({}, streams[idIdx]), { state: state_ });
+    return updateParticipant(state, participantId, { streams });
+}
+function removeClient(state, participantId) {
+    return Object.assign(Object.assign({}, state), { remoteParticipants: state.remoteParticipants.filter((c) => c.id !== participantId) });
+}
+function addStreamId(state, participantId, streamId) {
+    const { participant } = findParticipant(state, participantId);
+    if (!participant || participant.streams.find((s) => s.id === streamId)) {
+        console.warn(`No participant ${participantId} or stream ${streamId} already exists`);
+        return state;
+    }
+    return updateParticipant(state, participantId, {
+        streams: [...participant.streams, { id: streamId, state: "to_accept" }],
+    });
+}
+function removeStreamId(state, participantId, streamId) {
+    var _a, _b;
+    const { participant } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`No participant ${participantId} found to remove stream ${streamId}`);
+        return state;
+    }
+    const currentStreamId = participant.stream && participant.stream.id;
+    const presentationId = ((_a = participant.presentationStream) === null || _a === void 0 ? void 0 : _a.inboundId) || ((_b = participant.presentationStream) === null || _b === void 0 ? void 0 : _b.id);
+    const idIdx = participant.streams.findIndex((s) => s.id === streamId);
+    return updateParticipant(state, participantId, Object.assign(Object.assign({ streams: participant.streams.filter((_, i) => i !== idIdx) }, (currentStreamId === streamId && { stream: null })), (presentationId === streamId && { presentationStream: null })));
+}
+function addStream(state, payload) {
+    const { clientId, stream, streamType } = payload;
+    let { streamId } = payload;
+    const { participant } = findParticipant(state, clientId);
+    if (!participant) {
+        console.error(`Did not find client ${clientId} for adding stream`);
+        return state;
+    }
+    const remoteParticipants = state.remoteParticipants;
+    if (!streamId) {
+        streamId = stream.id;
+    }
+    const remoteParticipant = remoteParticipants.find((p) => p.id === clientId);
+    if (!remoteParticipant) {
+        return state;
+    }
+    const remoteParticipantStream = remoteParticipant.streams.find((s) => s.id === streamId);
+    if ((remoteParticipant.stream &&
+        (remoteParticipant.stream.id === streamId || remoteParticipant.stream.inboundId === streamId)) ||
+        (!remoteParticipant.stream && streamType === "webcam") ||
+        (!remoteParticipant.stream && !streamType && !remoteParticipantStream)) {
+        return updateParticipant(state, clientId, { stream });
+    }
+    return updateParticipant(state, clientId, {
+        presentationStream: stream,
+    });
+}
+const remoteParticipantsSliceInitialState = {
+    remoteParticipants: [],
+};
+const remoteParticipantsSlice = createSlice({
+    name: "remoteParticipants",
+    initialState: remoteParticipantsSliceInitialState,
+    reducers: {
+        streamStatusUpdated: (state, action) => {
+            let newState = state;
+            for (const { clientId, streamId, state } of action.payload) {
+                newState = updateStreamState(newState, clientId, streamId, state);
+            }
+            return newState;
+        },
+        participantStreamAdded: (state, action) => {
+            const { clientId, stream } = action.payload;
+            return updateParticipant(state, clientId, {
+                stream,
+            });
+        },
+        participantStreamIdAdded: (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return addStreamId(state, clientId, streamId);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            if ("error" in action.payload) {
+                return state;
+            }
+            const { room, selfId } = action.payload || {};
+            if (room === null || room === void 0 ? void 0 : room.clients) {
+                return Object.assign(Object.assign({}, state), { remoteParticipants: room.clients
+                        .filter((c) => c.id !== selfId)
+                        .map((c) => createRemoteParticipant(c)) });
+            }
+            return state;
+        });
+        builder.addCase(rtcEvents.streamAdded, (state, action) => {
+            return addStream(state, action.payload);
+        });
+        builder.addCase(signalEvents.newClient, (state, action) => {
+            const { client } = action.payload;
+            return addParticipant(state, createRemoteParticipant(client, true));
+        });
+        builder.addCase(signalEvents.clientLeft, (state, action) => {
+            const { clientId } = action.payload;
+            return removeClient(state, clientId);
+        });
+        builder.addCase(signalEvents.audioEnabled, (state, action) => {
+            const { clientId, isAudioEnabled } = action.payload;
+            return updateParticipant(state, clientId, {
+                isAudioEnabled,
+            });
+        });
+        builder.addCase(signalEvents.videoEnabled, (state, action) => {
+            const { clientId, isVideoEnabled } = action.payload;
+            return updateParticipant(state, clientId, {
+                isVideoEnabled,
+            });
+        });
+        builder.addCase(signalEvents.clientMetadataReceived, (state, action) => {
+            const { error, payload } = action.payload;
+            if (error || !payload) {
+                console.warn(error || "Client metadata error received");
+                return state;
+            }
+            const { clientId, displayName, stickyReaction } = payload;
+            return updateParticipant(state, clientId, {
+                displayName,
+                stickyReaction,
+            });
+        });
+        builder.addCase(signalEvents.breakoutGroupJoined, (state, action) => {
+            const { clientId, group } = action.payload;
+            return updateParticipant(state, clientId, {
+                breakoutGroup: group || null,
+            });
+        });
+        builder.addCase(signalEvents.screenshareStarted, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return addStreamId(state, clientId, streamId);
+        });
+        builder.addCase(signalEvents.screenshareStopped, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return removeStreamId(state, clientId, streamId);
+        });
+    },
+});
+const { participantStreamAdded, participantStreamIdAdded, streamStatusUpdated } = remoteParticipantsSlice.actions;
+const doRequestAudioEnable = createAuthorizedRoomConnectedThunk((state) => selectIsAuthorizedToRequestAudioEnable(state), (payload) => (_, getState) => {
+    const state = getState();
+    const canEnableRemoteAudio = selectIsAuthorizedToAskToSpeak(state);
+    if (payload.enable && !canEnableRemoteAudio) {
+        console.warn("Not authorized to perform this action");
+        return;
+    }
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("request_audio_enable", payload);
+});
+const doRequestVideoEnable = createAuthorizedRoomConnectedThunk((state) => selectIsAuthorizedToRequestVideoEnable(state), (payload) => (_, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("request_video_enable", payload);
+});
+const selectRemoteParticipantsRaw = (state) => state.remoteParticipants;
+const selectRemoteClients = (state) => state.remoteParticipants.remoteParticipants;
+const selectRemoteParticipants = createSelector(selectRemoteClients, (clients) => clients.filter((c) => !NON_PERSON_ROLES.includes(c.roleName)));
+const selectNumClients = createSelector(selectRemoteClients, (clients) => clients.length + 1);
+const selectNumParticipants = createSelector(selectRemoteParticipants, selectLocalParticipantRaw, (clients, localParticipant) => {
+    if (NON_PERSON_ROLES.includes(localParticipant.roleName)) {
+        return clients.length;
+    }
+    return clients.length + 1;
+});
+
+const localScreenshareSliceInitialState = {
+    status: "inactive",
+    stream: null,
+    error: null,
+};
+const localScreenshareSlice = createSlice({
+    name: "localScreenshare",
+    initialState: localScreenshareSliceInitialState,
+    reducers: {
+        stopScreenshare(state, action) {
+            return Object.assign(Object.assign({}, state), { status: "inactive", stream: null });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doStartScreenshare.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "starting" });
+        });
+        builder.addCase(doStartScreenshare.fulfilled, (state, { payload: { stream } }) => {
+            return Object.assign(Object.assign({}, state), { status: "active", stream });
+        });
+        builder.addCase(doStartScreenshare.rejected, (state, { payload }) => {
+            return Object.assign(Object.assign({}, state), { error: payload, status: "inactive", stream: null });
+        });
+    },
+});
+const { stopScreenshare } = localScreenshareSlice.actions;
+const doStartScreenshare = createAsyncRoomConnectedThunk("localScreenshare/doStartScreenshare", (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { dispatch, getState, rejectWithValue }) {
+    var _b;
+    try {
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (screenshareStream) {
+            return { stream: screenshareStream };
+        }
+        const stream = yield navigator.mediaDevices.getDisplayMedia();
+        const onEnded = () => {
+            dispatch(doStopScreenshare());
+        };
+        if ("oninactive" in stream) {
+            stream.addEventListener("inactive", onEnded);
+        }
+        else {
+            (_b = stream.getVideoTracks()[0]) === null || _b === void 0 ? void 0 : _b.addEventListener("ended", onEnded);
+        }
+        return { stream };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doStopScreenshare = createRoomConnectedThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const screenshareStream = selectLocalScreenshareStream(state);
+    if (!screenshareStream) {
+        return;
+    }
+    screenshareStream.getTracks().forEach((track) => track.stop());
+    dispatch(stopScreenshare({ stream: screenshareStream }));
+});
+const selectLocalScreenshareRaw = (state) => state.localScreenshare;
+const selectLocalScreenshareStatus = (state) => state.localScreenshare.status;
+const selectLocalScreenshareStream = (state) => state.localScreenshare.stream;
+startAppListening({
+    actionCreator: localMediaStopped,
+    effect: (_, { getState }) => {
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (!screenshareStream) {
+            return;
+        }
+        screenshareStream === null || screenshareStream === void 0 ? void 0 : screenshareStream.getTracks().forEach((track) => {
+            track.stop();
+        });
+    },
+});
+
+function isStreamerClient(client) {
+    return client.roleName === "streamer";
+}
+function isRecorderClient(client) {
+    return client.roleName === "recorder";
+}
+const roomSliceInitialState = {
+    isLocked: false,
+};
+const roomSlice = createSlice({
+    name: "room",
+    initialState: roomSliceInitialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            if ("error" in action.payload) {
+                if (action.payload.error === "room_locked") {
+                    return Object.assign(Object.assign({}, state), { isLocked: Boolean(action.payload.isLocked) });
+                }
+                return state;
+            }
+            const { room } = action.payload;
+            return Object.assign(Object.assign({}, state), { isLocked: Boolean(room.isLocked) });
+        });
+        builder.addCase(signalEvents.roomLocked, (state, action) => {
+            const { isLocked } = action.payload;
+            return Object.assign(Object.assign({}, state), { isLocked: Boolean(isLocked) });
+        });
+    },
+});
+const doLockRoom = createAppAuthorizedThunk((state) => selectIsAuthorizedToLockRoom(state), (payload) => (_, getState) => {
+    const state = getState();
+    const { socket } = selectSignalConnectionRaw(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("set_lock", { locked: payload.locked });
+});
+const doKickParticipant = createAppAuthorizedThunk((state) => selectIsAuthorizedToKickClient(state), (payload) => (_, getState) => {
+    const state = getState();
+    const { socket } = selectSignalConnectionRaw(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("kick_client", { clientId: payload.clientId, reasonId: "kick" });
+});
+const doEndMeeting = createAppAuthorizedThunk((state) => selectIsAuthorizedToEndMeeting(state), (payload) => (dispatch, getState) => {
+    const state = getState();
+    const clientsToKick = selectRemoteClients(state).map((c) => c.id);
+    if (clientsToKick.length) {
+        const { socket } = selectSignalConnectionRaw(state);
+        socket === null || socket === void 0 ? void 0 : socket.emit("kick_client", { clientIds: clientsToKick, reasonId: "end-meeting" });
+    }
+    if (!payload.stayBehind) {
+        dispatch(doAppStop());
+    }
+});
+const selectRoomIsLocked = (state) => state.room.isLocked;
+const selectScreenshares = createSelector(selectLocalScreenshareStream, selectLocalParticipantRaw, selectRemoteParticipants, (localScreenshareStream, localParticipant, remoteParticipants) => {
+    const screenshares = [];
+    if (localScreenshareStream) {
+        screenshares.push({
+            id: localScreenshareStream.id || "local-screenshare",
+            participantId: "local",
+            hasAudioTrack: localScreenshareStream.getTracks().some((track) => track.kind === "audio"),
+            breakoutGroup: localParticipant.breakoutGroup,
+            stream: localScreenshareStream,
+            isLocal: true,
+        });
+    }
+    for (const participant of remoteParticipants) {
+        if (participant.presentationStream) {
+            screenshares.push({
+                id: participant.presentationStream.id || `pres-${participant.id}`,
+                participantId: participant.id,
+                hasAudioTrack: participant.presentationStream.getTracks().some((track) => track.kind === "audio"),
+                breakoutGroup: participant.breakoutGroup,
+                stream: participant.presentationStream,
+                isLocal: false,
+            });
+        }
+    }
+    return screenshares;
+});
+const selectRemoteClientViews = createSelector(selectLocalScreenshareStream, selectLocalParticipantRaw, selectRemoteParticipants, selectBreakoutCurrentId, selectBreakoutAssignments, (localScreenshareStream, localParticipant, remoteParticipants, breakoutCurrentId, breakoutAssignments) => {
+    const views = [];
+    if (localScreenshareStream) {
+        const isScreenshareAudioEnabled = !!localScreenshareStream.getAudioTracks().length;
+        views.push({
+            clientId: localParticipant.id,
+            displayName: "Your screenshare",
+            id: "local-screenshare",
+            isAudioEnabled: isScreenshareAudioEnabled,
+            isLocalClient: true,
+            isPresentation: true,
+            isVideoEnabled: true,
+            stream: localScreenshareStream,
+            breakoutGroup: breakoutCurrentId || "",
+        });
+    }
+    for (const c of remoteParticipants) {
+        if (isStreamerClient(c) || isRecorderClient(c)) {
+            continue;
+        }
+        const { presentationStream } = c, clientView = __rest(c, ["presentationStream"]);
+        const displayName = c.displayName || "Guest";
+        const isPresentationActive = presentationStream && presentationStream.active;
+        const presentationId = "pres-" + c.id;
+        const isStreamActive = c.stream && c.stream.active;
+        const isVideoEnabled = c.isVideoEnabled;
+        views.push(Object.assign(Object.assign(Object.assign({}, clientView), { breakoutGroupAssigned: (breakoutAssignments === null || breakoutAssignments === void 0 ? void 0 : breakoutAssignments[c.deviceId]) || "", clientId: c.id, displayName, hasActivePresentation: !!isPresentationActive }), (c.isVideoEnabled ? { isVideoEnabled } : {})));
+        if (isPresentationActive) {
+            views.push(Object.assign(Object.assign(Object.assign({}, clientView), { clientId: c.id, stream: c.presentationStream, displayName: `Screenshare (${displayName})`, id: presentationId, isPresentation: true, isVideoEnabled: true }), (isStreamActive && { isRecording: null })));
+        }
+    }
+    return views;
+});
+const selectAllClientViews = createSelector(selectLocalParticipantView, selectRemoteClientViews, (localParticipant, remoteParticipants) => {
+    return [...(localParticipant ? [localParticipant] : []), ...remoteParticipants];
+});
+const selectAllClientViewsInCurrentGroup = createSelector(selectAllClientViews, selectBreakoutActive, selectBreakoutCurrentId, (allClientViews, breakoutActive, breakoutCurrentId) => {
+    if (!breakoutActive || !breakoutCurrentId) {
+        return allClientViews;
+    }
+    return allClientViews.filter((client) => client.isLocalClient ||
+        client.breakoutGroup === (breakoutCurrentId || "") ||
+        (client.breakoutGroupAssigned && client.breakoutGroupAssigned === breakoutCurrentId));
+});
+const selectBreakoutGroupedParticipants = createSelector(selectAllClientViews, selectBreakoutActive, selectBreakoutGroups, (clientViews, breakoutActive, breakoutGroups) => {
+    if (!breakoutActive || !breakoutGroups)
+        return [];
+    const clientsInMainRoom = clientViews.filter((client) => !client.breakoutGroup || client.breakoutGroup === "");
+    const mainRoom = {
+        clients: clientsInMainRoom,
+        group: { id: "", name: "" },
+    };
+    const groups = Object.entries(breakoutGroups).map(([id, name]) => ({
+        clients: clientViews.filter((client) => !client.isPresentation && client.breakoutGroup === id),
+        group: { id, name },
+    }));
+    return [mainRoom, ...groups];
+});
+
+function streamIdForClient({ isPresentation, stream }) {
+    var _a, _b;
+    return isPresentation ? (_b = (_a = stream === null || stream === void 0 ? void 0 : stream.outboundId) !== null && _a !== void 0 ? _a : stream === null || stream === void 0 ? void 0 : stream.inboundId) !== null && _b !== void 0 ? _b : stream === null || stream === void 0 ? void 0 : stream.id : "0";
+}
+function isClientSpotlighted({ spotlights, isPresentation, clientId, stream, }) {
+    return !!spotlights.find((s) => {
+        const streamId = streamIdForClient({ isPresentation, stream });
+        return s.clientId === clientId && s.streamId === streamId;
+    });
+}
+function mergeSpotlight(spotlights, spotlight) {
+    const found = spotlights.find((s) => s.clientId === spotlight.clientId && s.streamId === spotlight.streamId);
+    if (found) {
+        return spotlights;
+    }
+    return spotlights.concat(spotlight);
+}
+function mapSpotlightsToClientViews(spotlights, clientViews) {
+    return spotlights.reduce((acc, s) => {
+        const clientView = clientViews.find((c) => s.clientId === c.clientId && s.streamId === streamIdForClient(c));
+        if (clientView && !acc.includes(clientView)) {
+            acc.push(clientView);
+        }
+        return acc;
+    }, []);
+}
+const spotlightsSliceInitialState = {
+    sorted: [],
+};
+const spotlightsSlice = createSlice({
+    name: "spotlights",
+    initialState: spotlightsSliceInitialState,
+    reducers: {
+        addSpotlight(state, action) {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: mergeSpotlight(state.sorted, { clientId, streamId }) });
+        },
+        removeSpotlight(state, action) {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: state.sorted.filter((s) => !(s.clientId === clientId && s.streamId === streamId)) });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a;
+            if ("error" in action.payload) {
+                return state;
+            }
+            const { room } = action.payload || {};
+            if (room) {
+                return Object.assign(Object.assign({}, state), { sorted: (_a = room.spotlights) !== null && _a !== void 0 ? _a : state.sorted });
+            }
+            return state;
+        });
+        builder.addCase(signalEvents.spotlightAdded, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: mergeSpotlight(state.sorted, { clientId, streamId }) });
+        });
+        builder.addCase(signalEvents.spotlightRemoved, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: state.sorted.filter((s) => !(s.clientId === clientId && s.streamId === streamId)) });
+        });
+        builder.addMatcher(isAnyOf(signalEvents.clientKicked, signalEvents.clientLeft), (state, action) => {
+            const { clientId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: state.sorted.filter((s) => s.clientId !== clientId) });
+        });
+    },
+});
+const { addSpotlight, removeSpotlight } = spotlightsSlice.actions;
+const doSpotlightParticipant = createAppAuthorizedThunk((state) => selectIsAuthorizedToSpotlight(state), ({ id }) => (_, getState) => {
+    const state = getState();
+    const clientView = selectAllClientViews(state).find((c) => c.clientId === id);
+    if (!clientView) {
+        return;
+    }
+    const { socket } = selectSignalConnectionRaw(state);
+    const streamId = streamIdForClient(clientView);
+    const payload = { clientId: clientView.id, streamId: streamId !== null && streamId !== void 0 ? streamId : "0" };
+    socket === null || socket === void 0 ? void 0 : socket.emit("add_spotlight", payload);
+});
+const doRemoveSpotlight = createAppAuthorizedThunk((state) => selectIsAuthorizedToSpotlight(state), ({ id }) => (_, getState) => {
+    const state = getState();
+    const clientView = selectAllClientViews(state).find((c) => c.clientId === id);
+    if (!clientView) {
+        return;
+    }
+    const { socket } = selectSignalConnectionRaw(state);
+    const streamId = streamIdForClient(clientView);
+    const payload = { clientId: clientView.id, streamId: streamId !== null && streamId !== void 0 ? streamId : "0" };
+    socket === null || socket === void 0 ? void 0 : socket.emit("remove_spotlight", payload);
+});
+const selectSpotlightsRaw = (state) => state.spotlights;
+const selectSpotlights = (state) => state.spotlights.sorted;
+const selectIsLocalParticipantSpotlighted = createSelector(selectLocalParticipantRaw, selectSpotlights, (localParticipant, spotlights) => {
+    return isClientSpotlighted({ clientId: localParticipant.id, stream: localParticipant.stream, spotlights });
+});
+const selectSpotlightedClientViews = createSelector(selectAllClientViews, selectSpotlights, (clientViews, spotlights) => {
+    return mapSpotlightsToClientViews(spotlights, clientViews);
+});
+startAppListening({
+    actionCreator: doStartScreenshare.fulfilled,
+    effect: ({ payload }, { getState, dispatch }) => {
+        const { stream } = payload;
+        const state = getState();
+        const localParticipant = selectLocalParticipantRaw(state);
+        if (!localParticipant) {
+            return;
+        }
+        dispatch(addSpotlight({ clientId: localParticipant.id, streamId: stream.id }));
+    },
+});
+startAppListening({
+    actionCreator: stopScreenshare,
+    effect: ({ payload }, { getState, dispatch }) => {
+        const { stream } = payload;
+        const state = getState();
+        const localParticipant = selectLocalParticipantRaw(state);
+        if (!localParticipant) {
+            return;
+        }
+        dispatch(removeSpotlight({ clientId: localParticipant.id, streamId: stream.id }));
+    },
+});
+
+function isDeferrable({ client, breakoutCurrentId }) {
+    if (!client)
+        return false;
+    if (!breakoutCurrentId && client.breakoutGroup)
+        return true;
+    if (!client.isAudioEnabled && !client.isVideoEnabled)
+        return true;
+    return false;
+}
+const createWebRtcEmitter = (dispatch) => {
+    return {
+        emit: (eventName, data) => {
+            if (eventName === "rtc_manager_created") {
+                dispatch(doRtcManagerCreated(data));
+            }
+            else if (eventName === "stream_added") {
+                dispatch(rtcEvents.streamAdded(data));
+            }
+            else if (eventName === "rtc_manager_destroyed") {
+                dispatch(rtcManagerDestroyed());
+            }
+            else if (eventName === "client_connection_status_changed") {
+                dispatch(rtcEvents.clientConnectionStatusChanged(data));
+            }
+            else ;
+        },
+    };
+};
+const rtcConnectionSliceInitialState = {
+    dispatcherCreated: false,
+    error: null,
+    isCreatingDispatcher: false,
+    reportedStreamResolutions: {},
+    rtcManager: null,
+    rtcManagerDispatcher: null,
+    rtcManagerInitialized: false,
+    status: "inactive",
+    isAcceptingStreams: false,
+};
+const rtcConnectionSlice = createSlice({
+    name: "rtcConnection",
+    initialState: rtcConnectionSliceInitialState,
+    reducers: {
+        isAcceptingStreams: (state, action) => {
+            return Object.assign(Object.assign({}, state), { isAcceptingStreams: action.payload });
+        },
+        resolutionReported: (state, action) => {
+            const { streamId, width, height } = action.payload;
+            return Object.assign(Object.assign({}, state), { reportedStreamResolutions: Object.assign(Object.assign({}, state.reportedStreamResolutions), { [streamId]: { width, height } }) });
+        },
+        rtcDisconnected: () => {
+            return Object.assign({}, rtcConnectionSliceInitialState);
+        },
+        rtcDispatcherCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { dispatcherCreated: true, rtcManagerDispatcher: action.payload });
+        },
+        rtcManagerCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: action.payload, status: "ready" });
+        },
+        rtcManagerDestroyed: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: null });
+        },
+        rtcManagerInitialized: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManagerInitialized: true });
+        },
+        rtcClientConnectionStatusChanged: {
+            reducer: (state) => {
+                return state;
+            },
+            prepare: (payload) => {
+                return {
+                    payload: {},
+                    meta: {
+                        localParticipantId: payload.localParticipantId,
+                    },
+                };
+            },
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(socketReconnecting, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
+        });
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            if ("error" in action.payload) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { status: state.status === "reconnecting" ? "ready" : state.status });
+        });
+    },
+});
+const { resolutionReported, rtcDispatcherCreated, rtcDisconnected, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, isAcceptingStreams, rtcClientConnectionStatusChanged, } = rtcConnectionSlice.actions;
+const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const dispatcher = selectRtcConnectionRaw(state).rtcManagerDispatcher;
+    const isCameraEnabled = selectIsCameraEnabled(state);
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(state);
+    const isNodeSdk = selectAppIsNodeSdk(state);
+    if (dispatcher || !socket) {
+        return;
+    }
+    const webrtcProvider = {
+        getMediaConstraints: () => ({
+            audio: isMicrophoneEnabled,
+            video: isCameraEnabled,
+        }),
+        deferrable(clientId) {
+            const client = selectRemoteParticipants(getState()).find((p) => p.id === clientId);
+            const breakoutCurrentId = selectBreakoutCurrentId(getState()) || "";
+            return isDeferrable({ client, breakoutCurrentId });
+        },
+    };
+    const rtcManagerDispatcher = new RtcManagerDispatcher({
+        emitter: createWebRtcEmitter(dispatch),
+        serverSocket: socket,
+        webrtcProvider,
+        features: {
+            isNodeSdk,
+            lowDataModeEnabled: false,
+            sfuServerOverrideHost: undefined,
+            turnServerOverrideHost: undefined,
+            useOnlyTURN: undefined,
+            sfuVp9On: false,
+            h264On: false,
+            simulcastScreenshareOn: false,
+        },
+    });
+    dispatch(rtcDispatcherCreated(rtcManagerDispatcher));
+});
+const doDisconnectRtc = createAppThunk(() => (dispatch, getState) => {
+    const { rtcManager } = selectRtcConnectionRaw(getState());
+    if (rtcManager) {
+        rtcManager.disconnectAll();
+    }
+    dispatch(rtcDisconnected());
+});
+const doHandleAcceptStreams = createAppThunk((payload) => (dispatch, getState) => {
+    var _a;
+    dispatch(isAcceptingStreams(true));
+    const state = getState();
+    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+    const remoteClients = selectRemoteClients(state);
+    if (!rtcManager) {
+        throw new Error("No rtc manager");
+    }
+    const activeBreakout = selectBreakoutActive(state);
+    const shouldAcceptNewClients = (_a = rtcManager.shouldAcceptStreamsFromBothSides) === null || _a === void 0 ? void 0 : _a.call(rtcManager);
+    const updates = [];
+    for (const { clientId, streamId, state } of payload) {
+        const participant = remoteClients.find((p) => p.id === clientId);
+        if (!participant)
+            continue;
+        if (state === "to_accept" ||
+            (state === "new_accept" && shouldAcceptNewClients) ||
+            (state === "old_accept" && !shouldAcceptNewClients)) {
+            rtcManager.acceptNewStream({
+                streamId: streamId === "0" ? clientId : streamId,
+                clientId,
+                shouldAddLocalVideo: streamId === "0",
+                activeBreakout,
+            });
+        }
+        else if (state === "new_accept" || state === "old_accept") ;
+        else if (state === "to_unaccept") {
+            rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.disconnect(streamId === "0" ? clientId : streamId, activeBreakout);
+        }
+        else if (state !== "done_accept") {
+            continue;
+        }
+        else ;
+        updates.push({ clientId, streamId, state: state.replace(/to_|new_|old_/, "done_") });
+    }
+    dispatch(streamStatusUpdated(updates));
+    dispatch(isAcceptingStreams(false));
+});
+const doRtcReportStreamResolution = createAppThunk(({ streamId, width, height }) => (dispatch, getState) => {
+    const { reportedStreamResolutions, rtcManager } = selectRtcConnectionRaw(getState());
+    const localStream = selectLocalMediaStream(getState());
+    if (!rtcManager || (localStream === null || localStream === void 0 ? void 0 : localStream.id) === streamId) {
+        return;
+    }
+    const old = reportedStreamResolutions[streamId];
+    if (!old || old.width !== width || old.height !== height) {
+        rtcManager.updateStreamResolution(streamId, null, { width: width || 1, height: height || 1 });
+    }
+    dispatch(resolutionReported({ streamId, width, height }));
+});
+const doRtcManagerCreated = createAppThunk((payload) => (dispatch) => {
+    const { rtcManager } = payload;
+    dispatch(rtcManagerCreated(rtcManager));
+});
+const doRtcManagerInitialize = createAppThunk(() => (dispatch, getState) => {
+    const localMediaStream = selectLocalMediaStream(getState());
+    const rtcManager = selectRtcConnectionRaw(getState()).rtcManager;
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    if (localMediaStream && rtcManager) {
+        rtcManager.addNewStream("0", localMediaStream, !isMicrophoneEnabled, !isCameraEnabled);
+    }
+    dispatch(rtcManagerInitialized());
+});
+const selectRtcConnectionRaw = (state) => state.rtcConnection;
+const selectRtcManagerInitialized = (state) => state.rtcConnection.rtcManagerInitialized;
+const selectRtcManager = (state) => state.rtcConnection.rtcManager;
+const selectRtcDispatcherCreated = (state) => state.rtcConnection.dispatcherCreated;
+const selectRtcIsCreatingDispatcher = (state) => state.rtcConnection.isCreatingDispatcher;
+const selectRtcStatus = (state) => state.rtcConnection.status;
+const selectIsAcceptingStreams = (state) => state.rtcConnection.isAcceptingStreams;
+startAppListening({
+    actionCreator: doSetDevice.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { replacedTracks } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        const stream = selectLocalMediaStream(getState());
+        const replace = (kind, oldTrack) => {
+            const track = stream === null || stream === void 0 ? void 0 : stream.getTracks().find((t) => t.kind === kind);
+            return track && (rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.replaceTrack(oldTrack, track));
+        };
+        replacedTracks === null || replacedTracks === void 0 ? void 0 : replacedTracks.forEach((t) => {
+            replace(t.kind, t);
+        });
+    },
+});
+startAppListening({
+    actionCreator: doStartScreenshare.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.addNewStream(stream.id, stream, false, true);
+    },
+});
+startAppListening({
+    actionCreator: doAppStop,
+    effect: (_, { getState }) => {
+        const rtcManager = selectRtcManager(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.rtcStatsDisconnect();
+    },
+});
+startAppListening({
+    actionCreator: stopScreenshare,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.removeStream(stream.id, stream, null);
+    },
+});
+startAppListening({
+    actionCreator: doSwitchLocalStream.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        var _a;
+        const stream = selectLocalMediaStream(getState());
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        if (stream && rtcManager) {
+            const replace = (kind, oldTrack) => {
+                const track = stream.getTracks().find((t) => t.kind === kind);
+                return track && rtcManager.replaceTrack(oldTrack, track);
+            };
+            (_a = payload === null || payload === void 0 ? void 0 : payload.replacedTracks) === null || _a === void 0 ? void 0 : _a.forEach((t) => {
+                replace(t.kind, t);
+            });
+        }
+    },
+});
+startAppListening({
+    actionCreator: rtcEvents.clientConnectionStatusChanged,
+    effect: (_, { dispatch, getState }) => {
+        const localParticipant = selectLocalParticipantRaw(getState());
+        dispatch(rtcClientConnectionStatusChanged({ localParticipantId: localParticipant.id }));
+    },
+});
+const selectShouldConnectRtc = createSelector(selectRtcStatus, selectAppIsActive, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectSignalConnectionSocket, (rtcStatus, appIsActive, dispatcherCreated, isCreatingDispatcher, signalSocket) => {
+    if (appIsActive && rtcStatus === "inactive" && !dispatcherCreated && !isCreatingDispatcher && signalSocket) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRtc], ({ dispatch }, shouldConnectRtc) => {
+    if (shouldConnectRtc) {
+        dispatch(doConnectRtc());
+    }
+});
+const selectShouldInitializeRtc = createSelector(selectRtcManager, selectRtcManagerInitialized, selectLocalMediaStatus, (rtcManager, rtcManagerInitialized, localMediaStatus) => {
+    if (localMediaStatus === "started" && rtcManager && !rtcManagerInitialized) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldInitializeRtc], ({ dispatch }, shouldInitializeRtc) => {
+    if (shouldInitializeRtc) {
+        dispatch(doRtcManagerInitialize());
+    }
+});
+const selectShouldDisconnectRtc = createSelector(selectRtcStatus, selectAppIsActive, (status, appIsActive) => {
+    if (!appIsActive && !["inactive", "disconnected"].includes(status)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldDisconnectRtc], ({ dispatch }, shouldDisconnectRtc) => {
+    if (shouldDisconnectRtc) {
+        dispatch(doDisconnectRtc());
+    }
+});
+const selectStreamsToAccept = createSelector(selectRtcStatus, selectRemoteClients, selectBreakoutCurrentId, selectSpotlights, selectAppIgnoreBreakoutGroups, (rtcStatus, remoteParticipants, breakoutCurrentId, spotlights, ignoreBreakoutGroups) => {
+    if (rtcStatus !== "ready") {
+        return [];
+    }
+    const upd = [];
+    for (const client of remoteParticipants) {
+        const { streams, id: clientId, newJoiner } = client;
+        const clientSpotlight = spotlights.find((s) => s.clientId === client.id && s.streamId === "0");
+        for (let i = 0; i < streams.length; i++) {
+            let streamId = streams[i].id;
+            let state = streams[i].state;
+            if ((streams === null || streams === void 0 ? void 0 : streams.length) > 1 && streams[1].id === "0") {
+                if (i === 0) {
+                    streamId = streams[1].id;
+                    state = streams[1].state;
+                }
+                else if (i === 1) {
+                    streamId = streams[0].id;
+                    state = streams[0].state;
+                }
+            }
+            if ((!client.breakoutGroup && !breakoutCurrentId) ||
+                client.breakoutGroup === breakoutCurrentId ||
+                ("" === client.breakoutGroup && clientSpotlight) ||
+                ignoreBreakoutGroups) {
+                if (state === "done_accept")
+                    continue;
+                upd.push({
+                    clientId,
+                    streamId,
+                    state: `${newJoiner && streamId === "0" ? "new" : "to"}_accept`,
+                });
+            }
+            else {
+                if (state === "done_unaccept")
+                    continue;
+                upd.push({ clientId, streamId, state: "to_unaccept" });
+            }
+        }
+    }
+    return upd;
+});
+createReactor([selectStreamsToAccept, selectIsAcceptingStreams], ({ dispatch }, streamsToAccept, isAcceptingStreams) => {
+    if (0 < streamsToAccept.length && !isAcceptingStreams) {
+        dispatch(doHandleAcceptStreams(streamsToAccept));
+    }
+});
+
+const connectionMonitorSliceInitialState = {
+    running: false,
+};
+const connectionMonitorSlice = createSlice({
+    name: "connectionMonitor",
+    initialState: connectionMonitorSliceInitialState,
+    reducers: {
+        connectionMonitorStarted: (state, action) => {
+            return Object.assign(Object.assign({}, state), { running: true, stopCallbackFunction: action.payload.stopIssueSubscription });
+        },
+        connectionMonitorStopped: () => {
+            return Object.assign({}, connectionMonitorSliceInitialState);
+        },
+    },
+});
+const { connectionMonitorStarted, connectionMonitorStopped } = connectionMonitorSlice.actions;
+const doStartConnectionMonitor = createAppThunk(() => (dispatch, getState) => {
+    setClientProvider(() => {
+        const state = getState();
+        const clientViews = selectAllClientViews(state).map((clientView) => {
+            var _a, _b;
+            return ({
+                id: clientView.id,
+                clientId: clientView.clientId,
+                isLocalClient: clientView.isLocalClient,
+                audio: {
+                    enabled: clientView.isAudioEnabled,
+                    track: (_a = clientView.stream) === null || _a === void 0 ? void 0 : _a.getAudioTracks()[0],
+                },
+                video: {
+                    enabled: clientView.isVideoEnabled,
+                    track: (_b = clientView.stream) === null || _b === void 0 ? void 0 : _b.getVideoTracks()[0],
+                },
+                isPresentation: clientView.isPresentation,
+            });
+        });
+        return clientViews;
+    });
+    const issueMonitorSubscription = subscribeIssues({
+        onUpdatedIssues: (issuesAndMetricsByClients) => {
+            var _a;
+            const state = getState();
+            const rtcManager = selectRtcManager(state);
+            if (!rtcManager) {
+                return;
+            }
+            let lossSend = 0;
+            let lossReceive = 0;
+            let bitrateSend = 0;
+            let bitrateReceive = 0;
+            Object.entries(issuesAndMetricsByClients.aggregated.metrics).forEach(([key, value]) => {
+                if (/loc.*packetloss/.test(key))
+                    lossSend = Math.max(lossSend, value.curMax);
+                if (/rem.*packetloss/.test(key))
+                    lossReceive = Math.max(lossReceive, value.curMax);
+                if (/loc.*bitrate/.test(key))
+                    bitrateSend += value.curSum;
+                if (/rem.*bitrate/.test(key))
+                    bitrateReceive += value.curSum;
+            });
+            rtcManager.sendStatsCustomEvent("insightsStats", {
+                ls: Math.round(lossSend * 1000) / 1000,
+                lr: Math.round(lossReceive * 1000) / 1000,
+                bs: Math.round(bitrateSend),
+                br: Math.round(bitrateReceive),
+                cpu: (_a = issuesAndMetricsByClients.aggregated.metrics["global-cpu-pressure"]) === null || _a === void 0 ? void 0 : _a.curSum,
+                _time: Date.now(),
+            });
+        },
+    });
+    dispatch(connectionMonitorStarted({ stopIssueSubscription: issueMonitorSubscription.stop }));
+});
+const doStopConnectionMonitor = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const stopCallbackFn = selectStopCallbackFunction(state);
+    if (stopCallbackFn) {
+        stopCallbackFn();
+    }
+    dispatch(connectionMonitorStopped());
+});
+const selectConnectionMonitorIsRunning = (state) => state.connectionMonitor.running;
+const selectStopCallbackFunction = (state) => state.connectionMonitor.stopCallbackFunction;
+const selectShouldStartConnectionMonitor = createSelector(selectRoomConnectionStatus, selectConnectionMonitorIsRunning, (roomConnectionStatus, isRunning) => {
+    if (!isRunning && roomConnectionStatus === "connected") {
+        return true;
+    }
+    return false;
+});
+const selectShouldStopConnectionMonitor = createSelector(selectRoomConnectionStatus, selectConnectionMonitorIsRunning, (roomConnectionStatus, isRunning) => {
+    if (isRunning && ["kicked", "left"].includes(roomConnectionStatus)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldStartConnectionMonitor], ({ dispatch }, shouldStartConnectionMonitor) => {
+    if (shouldStartConnectionMonitor) {
+        dispatch(doStartConnectionMonitor());
+    }
+});
+createReactor([selectShouldStopConnectionMonitor], ({ dispatch }, shouldStartConnectionMonitor) => {
+    if (shouldStartConnectionMonitor) {
+        dispatch(doStopConnectionMonitor());
+    }
+});
+
+const localParticipantSliceInitialState = {
+    displayName: "",
+    id: "",
+    breakoutGroup: null,
+    breakoutGroupAssigned: "",
+    isAudioEnabled: true,
+    isVideoEnabled: true,
+    isLocalParticipant: true,
+    stream: undefined,
+    isScreenSharing: false,
+    roleName: "none",
+    clientClaim: undefined,
+    stickyReaction: undefined,
+    isDialIn: false,
+};
+const localParticipantSlice = createSlice({
+    name: "localParticipant",
+    initialState: localParticipantSliceInitialState,
+    reducers: {
+        setDisplayName: (state, action) => {
+            return Object.assign(Object.assign({}, state), { displayName: action.payload.displayName });
+        },
+        setBreakoutGroupAssigned: (state, action) => {
+            return Object.assign(Object.assign({}, state), { breakoutGroupAssigned: action.payload.breakoutGroupAssigned });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppStart, (state, action) => {
+            return Object.assign(Object.assign({}, state), { displayName: action.payload.displayName });
+        });
+        builder.addCase(doEnableAudio.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isAudioEnabled: action.payload });
+        });
+        builder.addCase(doEnableVideo.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isVideoEnabled: action.payload });
+        });
+        builder.addCase(doSetLocalStickyReaction.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { stickyReaction: action.payload });
+        });
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a;
+            if ("error" in action.payload) {
+                if (action.payload.error === "room_locked") {
+                    return Object.assign(Object.assign({}, state), { id: action.payload.selfId });
+                }
+                return state;
+            }
+            const { room, selfId, clientClaim } = action.payload || {};
+            const client = room.clients.find((c) => c.id === selfId);
+            return Object.assign(Object.assign({}, state), { id: selfId, roleName: ((_a = client === null || client === void 0 ? void 0 : client.role) === null || _a === void 0 ? void 0 : _a.roleName) || "none", clientClaim, breakoutGroup: (client === null || client === void 0 ? void 0 : client.breakoutGroup) || null });
+        });
+        builder.addCase(signalEvents.breakoutGroupJoined, (state, action) => {
+            var _a, _b;
+            if (((_a = action.payload) === null || _a === void 0 ? void 0 : _a.clientId) !== state.id) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { breakoutGroup: (_b = action.payload) === null || _b === void 0 ? void 0 : _b.group });
+        });
+    },
+});
+const { setDisplayName, setBreakoutGroupAssigned } = localParticipantSlice.actions;
+const doSetDisplayName = createRoomConnectedThunk((payload) => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("send_client_metadata", {
+        type: "UserData",
+        payload: { displayName: payload.displayName },
+    });
+    dispatch(setDisplayName({ displayName: payload.displayName }));
+});
+const doEnableAudio = createAsyncRoomConnectedThunk("localParticipant/doEnableAudio", (payload_1, _a) => __awaiter(void 0, [payload_1, _a], void 0, function* (payload, { dispatch, getState }) {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("enable_audio", { enabled: payload.enabled });
+    if (payload.enabled) {
+        dispatch(doSetLocalStickyReaction({ enabled: false }));
+    }
+    return payload.enabled;
+}));
+const doEnableVideo = createAsyncRoomConnectedThunk("localParticipant/doEnableVideo", (payload_1, _a) => __awaiter(void 0, [payload_1, _a], void 0, function* (payload, { getState }) {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("enable_video", { enabled: payload.enabled });
+    return payload.enabled;
+}));
+const doSetLocalStickyReaction = createAsyncRoomConnectedThunk("localParticipant/doSetLocalStickyReaction", (payload_1, _a) => __awaiter(void 0, [payload_1, _a], void 0, function* (payload, { getState, rejectWithValue }) {
+    var _b;
+    const state = getState();
+    const currentStickyReaction = selectLocalParticipantStickyReaction(state);
+    const stickyReactionCurrentlyEnabled = Boolean(currentStickyReaction);
+    const enabled = (_b = payload.enabled) !== null && _b !== void 0 ? _b : !stickyReactionCurrentlyEnabled;
+    if (enabled === stickyReactionCurrentlyEnabled) {
+        return rejectWithValue(currentStickyReaction);
+    }
+    const stickyReaction = enabled ? { reaction: "✋", timestamp: new Date().toISOString() } : null;
+    return stickyReaction;
+}));
+const doSendClientMetadata = createRoomConnectedThunk(() => (_, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const payload = {
+        displayName: selectLocalParticipantDisplayName(state),
+        stickyReaction: selectLocalParticipantStickyReaction(state),
+    };
+    socket === null || socket === void 0 ? void 0 : socket.emit("send_client_metadata", {
+        type: "UserData",
+        payload,
+    });
+});
+startAppListening({
+    actionCreator: toggleCameraEnabled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enabled } = payload;
+        const { isVideoEnabled } = selectLocalParticipantRaw(getState());
+        const roomConnectionStatus = selectRoomConnectionStatus(getState());
+        if (roomConnectionStatus !== "connected") {
+            return;
+        }
+        dispatch(doEnableVideo({ enabled: enabled || !isVideoEnabled }));
+    },
+});
+startAppListening({
+    actionCreator: toggleMicrophoneEnabled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enabled } = payload;
+        const { isAudioEnabled } = selectLocalParticipantRaw(getState());
+        const roomConnectionStatus = selectRoomConnectionStatus(getState());
+        if (roomConnectionStatus !== "connected") {
+            return;
+        }
+        dispatch(doEnableAudio({ enabled: enabled || !isAudioEnabled }));
+    },
+});
+createReactor([selectLocalParticipantDisplayName, selectLocalParticipantStickyReaction, selectRoomConnectionStatus], ({ dispatch }, diplayName, stickyReaction, roomConnectionStatus) => {
+    if (roomConnectionStatus === "connected") {
+        dispatch(doSendClientMetadata());
+    }
+});
+createReactor([selectBreakoutAssignments, selectDeviceId, selectLocalParticipantRaw], ({ dispatch }, breakoutAssignments, deviceId, localParticipant) => {
+    const breakoutGroupAssigned = (breakoutAssignments === null || breakoutAssignments === void 0 ? void 0 : breakoutAssignments[deviceId || ""]) || "";
+    if (localParticipant.breakoutGroupAssigned === breakoutGroupAssigned) {
+        return;
+    }
+    dispatch(setBreakoutGroupAssigned({ breakoutGroupAssigned }));
+});
+
+const emitter = new EventEmitter();
+function createNotificationEvent(payload) {
+    const notificationEvent = Object.assign(Object.assign({}, payload), { timestamp: Date.now() });
+    return notificationEvent;
+}
+const initialNotificationsState = {
+    emitter,
+    events: [],
+};
+const notificationsSlice = createSlice({
+    name: "notifications",
+    initialState: initialNotificationsState,
+    reducers: {
+        addNotification: (state, action) => {
+            return Object.assign(Object.assign({}, state), { events: [...state.events, Object.assign({}, action.payload)] });
+        },
+        doClearNotifications: (state) => {
+            return Object.assign(Object.assign({}, state), { events: [] });
+        },
+    },
+});
+const { doClearNotifications } = notificationsSlice.actions;
+const doSetNotification = createAppThunk((payload) => (dispatch, getState) => {
+    dispatch(notificationsSlice.actions.addNotification(payload));
+    const state = getState();
+    const emitter = selectNotificationsEmitter(state);
+    emitter.emit(payload.type, payload);
+    emitter.emit("*", payload);
+});
+const selectNotificationsRaw = (state) => state.notifications;
+const selectNotificationsEvents = (state) => state.notifications.events;
+const selectNotificationsEmitter = (state) => state.notifications.emitter;
+startAppListening({
+    actionCreator: signalEvents.chatMessage,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === payload.senderId);
+        if (!client) {
+            console.warn("Could not find remote client that sent chat message");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "chatMessageReceived",
+            message: `${client.displayName} says: ${payload.text}`,
+            props: {
+                client,
+                chatMessage: {
+                    senderId: payload.senderId,
+                    timestamp: payload.timestamp,
+                    text: payload.text,
+                },
+            },
+        })));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.audioEnableRequested,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enable, requestedByClientId } = payload;
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === requestedByClientId);
+        if (!client) {
+            console.warn("Could not find remote client that requested a local audio change");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: enable ? "requestAudioEnable" : "requestAudioDisable",
+            message: enable
+                ? `${client.displayName} has requested for you to speak`
+                : `${client.displayName} has muted your microphone`,
+            props: {
+                client,
+                enable,
+            },
+        })));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.videoEnableRequested,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enable, requestedByClientId } = payload;
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === requestedByClientId);
+        if (!client) {
+            console.warn("Could not find remote client that requested a local video change");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: enable ? "requestVideoEnable" : "requestVideoDisable",
+            message: enable
+                ? `${client.displayName} has requested for you to start video`
+                : `${client.displayName} has stopped your video`,
+            props: {
+                client,
+                enable,
+            },
+        })));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.clientMetadataReceived,
+    effect: (action, { dispatch, getOriginalState, getState }) => {
+        var _a;
+        const { error, payload } = action.payload;
+        if (error || !payload) {
+            return;
+        }
+        const { clientId, stickyReaction } = payload;
+        const state = getState();
+        const canAskToSpeak = selectIsAuthorizedToAskToSpeak(state);
+        if (!canAskToSpeak) {
+            return;
+        }
+        const client = selectRemoteParticipants(state).find(({ id }) => id === clientId);
+        if (!client) {
+            console.warn("Could not find remote client that provided updated metadata");
+            return;
+        }
+        const previousState = getOriginalState();
+        const previousClient = selectRemoteParticipants(previousState).find(({ id }) => id === clientId);
+        if ((!stickyReaction && !(previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction)) ||
+            (stickyReaction === null || stickyReaction === void 0 ? void 0 : stickyReaction.timestamp) === ((_a = previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction) === null || _a === void 0 ? void 0 : _a.timestamp)) {
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: stickyReaction ? "remoteHandRaised" : "remoteHandLowered",
+            message: `${client.displayName} ${stickyReaction ? "raised" : "lowered"} their hand`,
+            props: {
+                client,
+                stickyReaction,
+            },
+        })));
+    },
+});
+createReactor([selectSignalStatus], ({ dispatch, getState }, signalStatus) => {
+    const state = getState();
+    const roomConnectionStatus = selectRoomConnectionStatus(state);
+    if (["left", "kicked"].includes(roomConnectionStatus)) {
+        return;
+    }
+    if (signalStatus === "disconnected") {
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "signalTrouble",
+            message: `Network connection lost. Trying to reconnect you...`,
+            props: {},
+        })));
+    }
+    else if (signalStatus === "connected") {
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "signalOk",
+            message: `Network connection available`,
+            props: {},
+        })));
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.clientUnableToJoin,
+    effect: (action, { dispatch }) => {
+        var _a;
+        if (((_a = action.payload) === null || _a === void 0 ? void 0 : _a.error) === "room_full") {
+            dispatch(doSetNotification(createNotificationEvent({
+                type: "clientUnableToJoinFullRoom",
+                message: "Someone tried to join but the room is full and at capacity.",
+                props: {},
+            })));
+        }
+    },
+});
+
+const organizationSliceInitialState = {
+    data: null,
+    isFetching: false,
+    error: null,
+};
+const organizationSlice = createSlice({
+    name: "organization",
+    initialState: organizationSliceInitialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(doOrganizationFetch.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+        builder.addCase(doOrganizationFetch.fulfilled, (state, action) => {
+            if (!action.payload)
+                return Object.assign(Object.assign({}, state), { isFetching: true });
+            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        });
+        builder.addCase(doOrganizationFetch.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: false, error: true });
+        });
+    },
+});
+const doOrganizationFetch = createAppAsyncThunk("organization/doOrganizationFetch", (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { extra, getState }) {
+    try {
+        const roomUrl = selectAppRoomUrl(getState());
+        const organization = yield extra.services.fetchOrganizationFromRoomUrl(roomUrl || "");
+        if (!organization) {
+            throw new Error("Invalid room url");
+        }
+        return organization;
+    }
+    catch (error) {
+        console.error(error);
+    }
+}));
+const selectOrganizationRaw = (state) => state.organization;
+const selectOrganizationId = (state) => { var _a; return (_a = state.organization.data) === null || _a === void 0 ? void 0 : _a.organizationId; };
+const selectOrganizationPreferences = (state) => { var _a; return (_a = state.organization.data) === null || _a === void 0 ? void 0 : _a.preferences; };
+const selectShouldFetchOrganization = createSelector(selectAppIsActive, selectOrganizationRaw, selectDeviceCredentialsRaw, (appIsActive, organization, deviceCredentials) => {
+    if (appIsActive &&
+        !organization.data &&
+        !organization.isFetching &&
+        !organization.error &&
+        !deviceCredentials.isFetching) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldFetchOrganization], ({ dispatch }, shouldFetchOrganization) => {
+    if (shouldFetchOrganization) {
+        dispatch(doOrganizationFetch());
+    }
+});
+
+const roomConnectionSliceInitialState = {
+    session: null,
+    status: "ready",
+    error: null,
+};
+const roomConnectionSlice = createSlice({
+    name: "roomConnection",
+    initialState: roomConnectionSliceInitialState,
+    reducers: {
+        connectionStatusChanged: (state, action) => {
+            return Object.assign(Object.assign({}, state), { status: action.payload });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a;
+            if ("error" in action.payload) {
+                if (action.payload.error === "room_locked" && action.payload.isLocked) {
+                    return Object.assign(Object.assign({}, state), { status: "room_locked" });
+                }
+                return Object.assign(Object.assign({}, state), { status: "disconnected", error: action.payload.error });
+            }
+            const { room } = action.payload;
+            return Object.assign(Object.assign({}, state), { status: "connected", session: (_a = room.session) !== null && _a !== void 0 ? _a : null });
+        });
+        builder.addCase(signalEvents.disconnect, (state) => {
+            if (["kicked", "left"].includes(state.status)) {
+                return Object.assign({}, state);
+            }
+            return Object.assign(Object.assign({}, state), { status: "disconnected" });
+        });
+        builder.addCase(signalEvents.newClient, (state, action) => {
+            var _a, _b;
+            return Object.assign(Object.assign({}, state), { session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
+        });
+        builder.addCase(signalEvents.roomSessionEnded, (state, action) => {
+            var _a;
+            if (((_a = state.session) === null || _a === void 0 ? void 0 : _a.id) !== action.payload.roomSessionId) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { session: null });
+        });
+        builder.addCase(signalEvents.clientKicked, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "kicked" });
+        });
+        builder.addCase(signalEvents.roomLeft, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "left" });
+        });
+        builder.addCase(socketReconnecting, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
+        });
+    },
+});
+const { connectionStatusChanged } = roomConnectionSlice.actions;
+const doKnockRoom = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const isDialIn = selectAppIsDialIn(state);
+    const userAgent = selectAppUserAgent(state);
+    const externalId = selectAppExternalId(state);
+    const organizationId = selectOrganizationId(state);
+    const connectionStatus = selectRoomConnectionStatus(state);
+    if (connectionStatus !== "room_locked") {
+        console.warn("Room is not locked, knock aborted");
+        return;
+    }
+    socket === null || socket === void 0 ? void 0 : socket.emit("knock_room", {
+        avatarUrl: null,
+        config: {
+            isAudioEnabled: true,
+            isVideoEnabled: true,
+        },
+        deviceCapabilities: { canScreenshare: true },
+        displayName,
+        isCoLocated: false,
+        isDialIn,
+        isDevicePermissionDenied: false,
+        kickFromOtherRooms: false,
+        organizationId,
+        roomKey,
+        roomName,
+        userAgent,
+        externalId,
+    });
+    dispatch(connectionStatusChanged("knocking"));
+});
+const doConnectRoom = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const userAgent = selectAppUserAgent(state);
+    const externalId = selectAppExternalId(state);
+    const isDialIn = selectAppIsDialIn(state);
+    const organizationId = selectOrganizationId(state);
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    const clientClaim = selectLocalParticipantClientClaim(getState());
+    socket === null || socket === void 0 ? void 0 : socket.emit("join_room", Object.assign({ avatarUrl: null, config: {
+            isAudioEnabled: isMicrophoneEnabled,
+            isVideoEnabled: isCameraEnabled,
+        }, deviceCapabilities: { canScreenshare: true }, displayName, isCoLocated: false, isDialIn, isDevicePermissionDenied: false, kickFromOtherRooms: false, organizationId,
+        roomKey,
+        roomName,
+        userAgent,
+        externalId }, (clientClaim && { clientClaim })));
+    dispatch(connectionStatusChanged("connecting"));
+});
+const selectShouldConnectRoom = createSelector([
+    selectAppIsActive,
+    selectOrganizationId,
+    selectRoomConnectionStatus,
+    selectSignalConnectionDeviceIdentified,
+    selectLocalMediaStatus,
+    selectRoomConnectionError,
+], (appIsActive, hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus, roomConnectionError) => {
+    if (appIsActive &&
+        localMediaStatus === "started" &&
+        signalConnectionDeviceIdentified &&
+        !!hasOrganizationIdFetched &&
+        ["ready", "reconnecting", "disconnected"].includes(roomConnectionStatus) &&
+        !roomConnectionError) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRoom], ({ dispatch }, shouldConnectRoom) => {
+    if (shouldConnectRoom) {
+        dispatch(doConnectRoom());
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.knockHandled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { clientId, resolution } = payload;
+        const state = getState();
+        const selfId = selectSelfId(state);
+        if (clientId !== selfId) {
+            return;
+        }
+        if (resolution === "accepted") {
+            dispatch(setRoomKey(payload.metadata.roomKey));
+            dispatch(doConnectRoom());
+        }
+        else if (resolution === "rejected") {
+            dispatch(connectionStatusChanged("knock_rejected"));
+        }
+    },
+});
+startAppListening({
+    actionCreator: doAppStop,
+    effect: (_, { dispatch, getState }) => {
+        const state = getState();
+        const roomConnectionStatus = selectRoomConnectionStatus(state);
+        if (roomConnectionStatus === "connected") {
+            const socket = selectSignalConnectionRaw(state).socket;
+            socket === null || socket === void 0 ? void 0 : socket.emit("leave_room");
+            dispatch(connectionStatusChanged("leaving"));
+        }
+        else {
+            doSignalDisconnect();
+        }
+    },
+});
+
+const rtcAnalyticsCustomEvents = {
+    audioEnabled: {
+        actions: [doEnableAudio.fulfilled],
+        rtcEventName: "audioEnabled",
+        getValue: (state) => selectIsMicrophoneEnabled(state),
+        getOutput: (value) => ({ enabled: value }),
+    },
+    videoEnabled: {
+        actions: [doEnableVideo.fulfilled],
+        rtcEventName: "videoEnabled",
+        getValue: (state) => selectIsCameraEnabled(state),
+        getOutput: (value) => ({ enabled: value }),
+    },
+    localStream: {
+        actions: [doSetDevice.fulfilled],
+        rtcEventName: "localStream",
+        getValue: (state) => {
+            var _a;
+            return (_a = selectLocalMediaStream(state)) === null || _a === void 0 ? void 0 : _a.getTracks().map((track) => ({ id: track.id, kind: track.kind, label: track.label }));
+        },
+        getOutput: (value) => ({ stream: value }),
+    },
+    localScreenshareStream: {
+        actions: [doStartScreenshare.fulfilled],
+        rtcEventName: "localScreenshareStream",
+        getValue: (state) => {
+            var _a;
+            return (_a = selectLocalScreenshareStream(state)) === null || _a === void 0 ? void 0 : _a.getTracks().map((track) => ({ id: track.id, kind: track.kind, label: track.label }));
+        },
+        getOutput: (value) => ({ tracks: value }),
+    },
+    localScreenshareStreamStopped: {
+        actions: [stopScreenshare],
+        rtcEventName: "localScreenshareStream",
+        getValue: () => () => null,
+        getOutput: () => ({}),
+    },
+    displayName: {
+        actions: [setDisplayName],
+        rtcEventName: "displayName",
+        getValue: (state) => {
+            const displayName = selectLocalParticipantDisplayName(state);
+            const prefs = selectOrganizationPreferences(state);
+            return (prefs === null || prefs === void 0 ? void 0 : prefs.hideInsightsDisplayNames) ? "[[redacted]]" : displayName;
+        },
+        getOutput: (value) => ({ displayName: value }),
+    },
+    clientId: {
+        actions: null,
+        rtcEventName: "clientId",
+        getValue: (state) => selectSelfId(state),
+        getOutput: (value) => ({ clientId: value }),
+    },
+    deviceId: {
+        actions: null,
+        rtcEventName: "deviceId",
+        getValue: (state) => selectDeviceId(state),
+        getOutput: (value) => ({ deviceId: value }),
+    },
+    externalId: {
+        actions: null,
+        rtcEventName: "externalId",
+        getValue: (state) => selectAppExternalId(state),
+        getOutput: (value) => ({ externalId: value }),
+    },
+    organizationId: {
+        actions: null,
+        rtcEventName: "organizationId",
+        getValue: (state) => selectOrganizationId(state),
+        getOutput: (value) => ({ organizationId: value }),
+    },
+    signalConnectionStatus: {
+        actions: null,
+        rtcEventName: "signalConnectionStatus",
+        getValue: (state) => selectSignalStatus(state),
+        getOutput: (value) => ({ status: value }),
+    },
+    roomSessionId: {
+        actions: [
+            signalEvents.newClient,
+            signalEvents.roomJoined,
+            signalEvents.roomSessionEnded,
+            signalEvents.clientLeft,
+        ],
+        rtcEventName: "roomSessionId",
+        getValue: (state) => selectRoomConnectionSessionId(state),
+        getOutput: (value) => ({ roomSessionId: value }),
+    },
+    rtcConnectionStatus: {
+        actions: null,
+        rtcEventName: "rtcConnectionStatus",
+        getValue: (state) => selectRtcStatus(state),
+        getOutput: (value) => ({ status: value }),
+    },
+    userRole: {
+        actions: null,
+        rtcEventName: "userRole",
+        getValue: (state) => selectAuthorizationRoleName(state),
+        getOutput: (value) => ({ userRole: value }),
+    },
+};
+const rtcCustomEventActions = Object.values(rtcAnalyticsCustomEvents)
+    .flatMap(({ actions }) => { var _a; return (_a = actions === null || actions === void 0 ? void 0 : actions.map((action) => action)) !== null && _a !== void 0 ? _a : null; })
+    .filter((action) => action !== null);
+const makeComparable = (value) => {
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return value;
+};
+const rtcAnalyticsSliceInitialState = {
+    reportedValues: {},
+};
+const rtcAnalyticsSlice = createSlice({
+    name: "rtcAnalytics",
+    initialState: rtcAnalyticsSliceInitialState,
+    reducers: {
+        updateReportedValues(state, action) {
+            return Object.assign(Object.assign({}, state), { reportedValues: Object.assign(Object.assign({}, state.reportedValues), { [action.payload.rtcEventName]: action.payload.value }) });
+        },
+    },
+});
+const doRtcAnalyticsCustomEventsInitialize = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+    if (!rtcManager)
+        return;
+    rtcManager.sendStatsCustomEvent("insightsStats", {
+        _time: Date.now(),
+        ls: 0,
+        lr: 0,
+        bs: 0,
+        br: 0,
+        cpu: 0,
+    });
+    Object.values(rtcAnalyticsCustomEvents).forEach(({ rtcEventName, getValue, getOutput }) => {
+        var _a;
+        const value = getValue(state);
+        const output = Object.assign(Object.assign({}, getOutput(value)), { _time: Date.now() });
+        const comparableValue = makeComparable(value);
+        if (((_a = state.rtcAnalytics.reportedValues) === null || _a === void 0 ? void 0 : _a[rtcEventName]) !== comparableValue) {
+            rtcManager.sendStatsCustomEvent(rtcEventName, output);
+            dispatch(updateReportedValues({ rtcEventName, value }));
+        }
+    });
+});
+const { updateReportedValues } = rtcAnalyticsSlice.actions;
+startAppListening({
+    matcher: isAnyOf(...rtcCustomEventActions),
+    effect: ({ type }, { getState, dispatch }) => {
+        var _a;
+        const state = getState();
+        const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+        if (!rtcManager)
+            return;
+        const rtcCustomEvent = Object.values(rtcAnalyticsCustomEvents).find(({ actions }) => actions === null || actions === void 0 ? void 0 : actions.map((a) => a.type).includes(type));
+        if (!rtcCustomEvent)
+            return;
+        const { getValue, getOutput, rtcEventName } = rtcCustomEvent;
+        const value = getValue(state);
+        const comparableValue = makeComparable(value);
+        const output = Object.assign(Object.assign({}, getOutput(value)), { _time: Date.now() });
+        if (((_a = state.rtcAnalytics.reportedValues) === null || _a === void 0 ? void 0 : _a[rtcEventName]) !== comparableValue) {
+            rtcManager.sendStatsCustomEvent(rtcEventName, output);
+            dispatch(updateReportedValues({ rtcEventName, value }));
+        }
+    },
+});
+createReactor([selectRtcManagerInitialized], ({ dispatch }, selectRtcManagerInitialized) => {
+    if (selectRtcManagerInitialized) {
+        dispatch(doRtcAnalyticsCustomEventsInitialize());
+    }
+});
+
+const streamingSliceInitialState = {
+    isStreaming: false,
+    error: null,
+    startedAt: undefined,
+};
+const streamingSlice = createSlice({
+    name: "streaming",
+    initialState: streamingSliceInitialState,
+    reducers: {
+        doHandleStreamingStarted: (state) => {
+            return Object.assign(Object.assign({}, state), { isStreaming: true, error: null, startedAt: new Date().getTime() });
+        },
+        doHandleStreamingStopped: (state) => {
+            return Object.assign(Object.assign({}, state), { isStreaming: false });
+        },
+    },
+});
+const { doHandleStreamingStarted, doHandleStreamingStopped } = streamingSlice.actions;
+const selectStreamingRaw = (state) => state.streaming;
+
+const waitingParticipantsSliceInitialState = {
+    waitingParticipants: [],
+};
+const waitingParticipantsSlice = createSlice({
+    name: "waitingParticipants",
+    initialState: waitingParticipantsSliceInitialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            if ("error" in action.payload) {
+                return state;
+            }
+            const { room } = action.payload;
+            if (room.knockers.length) {
+                return Object.assign(Object.assign({}, state), { waitingParticipants: room.knockers.map((knocker) => ({
+                        id: knocker.clientId,
+                        displayName: knocker.displayName,
+                    })) });
+            }
+            return state;
+        });
+        builder.addCase(signalEvents.roomKnocked, (state, action) => {
+            const { clientId, displayName } = action.payload;
+            return Object.assign(Object.assign({}, state), { waitingParticipants: [...state.waitingParticipants, { id: clientId, displayName }] });
+        });
+        builder.addCase(signalEvents.knockerLeft, (state, action) => {
+            const { clientId } = action.payload;
+            return Object.assign(Object.assign({}, state), { waitingParticipants: state.waitingParticipants.filter((p) => p.id !== clientId) });
+        });
+    },
+});
+const doAcceptWaitingParticipant = createRoomConnectedThunk((payload) => (dispatch, getState) => {
+    const { participantId } = payload;
+    const state = getState();
+    const socket = selectSignalConnectionSocket(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("handle_knock", {
+        action: "accept",
+        clientId: participantId,
+        response: {},
+    });
+});
+const doRejectWaitingParticipant = createRoomConnectedThunk((payload) => (dispatch, getState) => {
+    const { participantId } = payload;
+    const state = getState();
+    const socket = selectSignalConnectionSocket(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("handle_knock", {
+        action: "reject",
+        clientId: participantId,
+        response: {},
+    });
+});
+const selectWaitingParticipantsRaw = (state) => state.waitingParticipants;
+const selectWaitingParticipants = (state) => state.waitingParticipants.waitingParticipants;
+
+const IS_DEV = undefined === "true";
+const appReducer = combineReducers({
+    app: appSlice.reducer,
+    authorization: authorizationSlice.reducer,
+    breakout: breakoutSlice.reducer,
+    chat: chatSlice.reducer,
+    cloudRecording: cloudRecordingSlice.reducer,
+    connectionMonitor: connectionMonitorSlice.reducer,
+    deviceCredentials: deviceCredentialsSlice.reducer,
+    localMedia: localMediaSlice.reducer,
+    localParticipant: localParticipantSlice.reducer,
+    localScreenshare: localScreenshareSlice.reducer,
+    notifications: notificationsSlice.reducer,
+    organization: organizationSlice.reducer,
+    remoteParticipants: remoteParticipantsSlice.reducer,
+    room: roomSlice.reducer,
+    roomConnection: roomConnectionSlice.reducer,
+    rtcAnalytics: rtcAnalyticsSlice.reducer,
+    rtcConnection: rtcConnectionSlice.reducer,
+    signalConnection: signalConnectionSlice.reducer,
+    spotlights: spotlightsSlice.reducer,
+    streaming: streamingSlice.reducer,
+    waitingParticipants: waitingParticipantsSlice.reducer,
+});
+const rootReducer = (state, action) => {
+    var _a;
+    if (doAppStart.match(action)) {
+        const resetState = {
+            app: Object.assign(Object.assign({}, appSlice.getInitialState()), { initialConfig: (_a = state === null || state === void 0 ? void 0 : state.app) === null || _a === void 0 ? void 0 : _a.initialConfig }),
+            localMedia: Object.assign(Object.assign({}, localMediaSlice.getInitialState()), state === null || state === void 0 ? void 0 : state.localMedia),
+        };
+        return appReducer(resetState, action);
+    }
+    return appReducer(state, action);
+};
+const createStore = ({ preloadedState, injectServices, }) => {
+    return configureStore({
+        devTools: IS_DEV,
+        reducer: rootReducer,
+        middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+            thunk: {
+                extraArgument: { services: injectServices },
+            },
+            serializableCheck: false,
+        }).prepend(listenerMiddleware.middleware),
+        preloadedState,
+    });
+};
+const observeStore = (store, select, onChange) => {
+    let currentState;
+    function handleChange() {
+        const nextState = select(store.getState());
+        if (nextState !== currentState) {
+            currentState = nextState;
+            onChange(currentState);
+        }
+    }
+    const unsubscribe = store.subscribe(handleChange);
+    handleChange();
+    return unsubscribe;
+};
+
+export { addAppListener, addSpotlight, appSlice, authorizationSlice, authorizationSliceInitialState, breakoutSlice, breakoutSliceInitialState, chatSlice, chatSliceInitialState, cloudRecordingSlice, connectionMonitorSlice, connectionMonitorSliceInitialState, connectionMonitorStarted, connectionMonitorStopped, createAppAsyncThunk, createAppAuthorizedThunk, createAppThunk, createAsyncRoomConnectedThunk, createAuthorizedRoomConnectedThunk, createReactor, createRemoteParticipant, createRoomConnectedThunk, createStore, createWebRtcEmitter, deviceBusy, deviceCredentialsSlice, deviceCredentialsSliceInitialState, deviceIdentified, deviceIdentifying, doAcceptWaitingParticipant, doAppStart, doAppStop, doBreakoutJoin, doClearNotifications, doConnectRoom, doConnectRtc, doDisconnectRtc, doEnableAudio, doEnableVideo, doEndMeeting, doGetDeviceCredentials, doHandleAcceptStreams, doHandleStreamingStarted, doHandleStreamingStopped, doKickParticipant, doKnockRoom, doLockRoom, doOrganizationFetch, doRejectWaitingParticipant, doRemoveSpotlight, doRequestAudioEnable, doRequestVideoEnable, doRtcAnalyticsCustomEventsInitialize, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSendChatMessage, doSendClientMetadata, doSetDevice, doSetDisplayName, doSetLocalStickyReaction, doSetNotification, doSignalConnect, doSignalDisconnect, doSignalIdentifyDevice, doSpotlightParticipant, doStartCloudRecording, doStartConnectionMonitor, doStartLocalMedia, doStartScreenshare, doStopCloudRecording, doStopConnectionMonitor, doStopLocalMedia, doStopScreenshare, doSwitchLocalStream, doToggleCamera, doToggleLowDataMode, doUpdateDeviceList, initialCloudRecordingState, initialLocalMediaState, initialNotificationsState, initialState, isAcceptingStreams, isClientSpotlighted, listenerMiddleware, localMediaSlice, localMediaStopped, localParticipantSlice, localParticipantSliceInitialState, localScreenshareSlice, localScreenshareSliceInitialState, localStreamMetadataUpdated, notificationsSlice, observeStore, organizationSlice, organizationSliceInitialState, participantStreamAdded, participantStreamIdAdded, recordingRequestStarted, remoteParticipantsSlice, remoteParticipantsSliceInitialState, removeSpotlight, resolutionReported, roomConnectionSlice, roomConnectionSliceInitialState, roomSlice, roomSliceInitialState, rootReducer, rtcAnalyticsCustomEvents, rtcAnalyticsSlice, rtcAnalyticsSliceInitialState, rtcClientConnectionStatusChanged, rtcConnectionSlice, rtcConnectionSliceInitialState, rtcDisconnected, rtcDispatcherCreated, rtcEvents, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, selectAllClientViews, selectAllClientViewsInCurrentGroup, selectAppDisplayName, selectAppExternalId, selectAppIgnoreBreakoutGroups, selectAppInitialConfig, selectAppIsActive, selectAppIsDialIn, selectAppIsNodeSdk, selectAppRaw, selectAppRoomName, selectAppRoomUrl, selectAppUserAgent, selectAuthorizationRoleName, selectBreakoutActive, selectBreakoutAssignments, selectBreakoutCurrentGroup, selectBreakoutCurrentId, selectBreakoutGroupedParticipants, selectBreakoutGroups, selectBreakoutInitiatedBy, selectBreakoutRaw, selectBusyDeviceIds, selectCameraDeviceError, selectCameraDevices, selectChatMessages, selectChatRaw, selectCloudRecordingError, selectCloudRecordingRaw, selectCloudRecordingStartedAt, selectCloudRecordingStatus, selectConnectionMonitorIsRunning, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectCurrentSpeakerDeviceId, selectDeviceCredentialsRaw, selectDeviceId, selectHasFetchedDeviceCredentials, selectIsAcceptingStreams, selectIsAuthorizedToAskToSpeak, selectIsAuthorizedToEndMeeting, selectIsAuthorizedToKickClient, selectIsAuthorizedToLockRoom, selectIsAuthorizedToRequestAudioEnable, selectIsAuthorizedToRequestVideoEnable, selectIsAuthorizedToSpotlight, selectIsCameraEnabled, selectIsCloudRecording, selectIsLocalMediaStarting, selectIsLocalParticipantSpotlighted, selectIsLowDataModeEnabled, selectIsMicrophoneEnabled, selectIsSettingCameraDevice, selectIsSettingMicrophoneDevice, selectIsToggleCamera, selectLocalMediaConstraintsOptions, selectLocalMediaDevices, selectLocalMediaIsSwitchingStream, selectLocalMediaOptions, selectLocalMediaOwnsStream, selectLocalMediaRaw, selectLocalMediaShouldStartWithOptions, selectLocalMediaShouldStop, selectLocalMediaStartError, selectLocalMediaStatus, selectLocalMediaStream, selectLocalParticipantBreakoutAssigned, selectLocalParticipantBreakoutGroup, selectLocalParticipantClientClaim, selectLocalParticipantDisplayName, selectLocalParticipantIsScreenSharing, selectLocalParticipantRaw, selectLocalParticipantStickyReaction, selectLocalParticipantView, selectLocalScreenshareRaw, selectLocalScreenshareStatus, selectLocalScreenshareStream, selectMicrophoneDeviceError, selectMicrophoneDevices, selectNotificationsEmitter, selectNotificationsEvents, selectNotificationsRaw, selectNumClients, selectNumParticipants, selectOrganizationId, selectOrganizationPreferences, selectOrganizationRaw, selectRemoteClientViews, selectRemoteClients, selectRemoteParticipants, selectRemoteParticipantsRaw, selectRoomConnectionError, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRoomIsLocked, selectRoomKey, selectRtcConnectionRaw, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectRtcManager, selectRtcManagerInitialized, selectRtcStatus, selectScreenshares, selectSelfId, selectShouldConnectRoom, selectShouldConnectRtc, selectShouldConnectSignal, selectShouldDisconnectRtc, selectShouldFetchDeviceCredentials, selectShouldFetchOrganization, selectShouldIdentifyDevice, selectShouldInitializeRtc, selectShouldStartConnectionMonitor, selectShouldStopConnectionMonitor, selectSignalConnectionDeviceIdentified, selectSignalConnectionRaw, selectSignalConnectionSocket, selectSignalIsIdentifyingDevice, selectSignalStatus, selectSpeakerDevices, selectSpotlightedClientViews, selectSpotlights, selectSpotlightsRaw, selectStopCallbackFunction, selectStreamingRaw, selectStreamsToAccept, selectWaitingParticipants, selectWaitingParticipantsRaw, setBreakoutGroupAssigned, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setCurrentSpeakerDeviceId, setDisplayName, setLocalMediaOptions, setLocalMediaStream, setRoomKey, signalConnectionSlice, signalConnectionSliceInitialState, signalEvents, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, spotlightsSlice, spotlightsSliceInitialState, startAppListening, stopScreenshare, streamIdForClient, streamStatusUpdated, streamingSlice, streamingSliceInitialState, toggleCameraEnabled, toggleLowDataModeEnabled, toggleMicrophoneEnabled, updateReportedValues, waitingParticipantsSlice, waitingParticipantsSliceInitialState };