vg-x07df 1.9.2 → 1.9.3

package/dist/index.cjs

@@ -9,6 +9,7 @@ var immer$1 = require('immer');
 var mitt = require('mitt');
 var livekitClient = require('livekit-client');
 var componentsReact = require('@livekit/components-react');
+require('@livekit/track-processors');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -1406,6 +1407,301 @@ var callRecordingStoppedSchema = zod.z.object({
   egressId: zod.z.string(),
   state: zod.z.string()
 }).strict();
+var defaultChatState = {
+  byId: {},
+  order: [],
+  pendingOps: {},
+  participantCache: {},
+  maxEntries: 1e3
+};
+function applyReactionToEntry(entry, emoji, participantId, op) {
+  const emojiSet = entry.reactions[emoji];
+  if (!emojiSet) {
+    entry.reactions[emoji] = /* @__PURE__ */ new Set();
+  }
+  if (op === "add") {
+    entry.reactions[emoji]?.add(participantId);
+  } else {
+    entry.reactions[emoji]?.delete(participantId);
+    if (entry.reactions[emoji]?.size === 0) {
+      delete entry.reactions[emoji];
+    }
+  }
+}
+function trimEntriesIfNeeded(state) {
+  if (Object.keys(state.byId).length > state.maxEntries) {
+    const entriesToRemove = Object.keys(state.byId).length - state.maxEntries;
+    for (let i = 0; i < entriesToRemove; i++) {
+      const oldestId = state.order[i];
+      if (oldestId) {
+        delete state.byId[oldestId];
+      }
+    }
+    state.order = state.order.slice(entriesToRemove);
+  }
+}
+var useChatStore = zustand.create()(
+  immer.immer((set) => ({
+    ...defaultChatState,
+    patch: (fn) => set((state) => {
+      fn(state);
+    }),
+    applyIncoming: (envelope) => set((state) => {
+      if (envelope.kind === "entry") {
+        if (state.byId[envelope.entryId]) {
+          return;
+        }
+        if (envelope.sender.info) {
+          state.participantCache[envelope.sender.id] = envelope.sender.info;
+        }
+        const entry = {
+          id: envelope.entryId,
+          content: envelope.payload.content,
+          sender: {
+            id: envelope.sender.id
+          },
+          createdAt: envelope.ts,
+          version: 1,
+          reactions: {},
+          status: "sent",
+          filename: envelope.payload?.meta?.filename
+        };
+        state.byId[envelope.entryId] = entry;
+        state.order.push(envelope.entryId);
+        trimEntriesIfNeeded(state);
+        const pendingOps = state.pendingOps[envelope.entryId];
+        if (pendingOps) {
+          delete state.pendingOps[envelope.entryId];
+          for (const op of pendingOps) {
+            if (op.kind === "edit") {
+              const entry2 = state.byId[op.entryId];
+              if (entry2 && op.payload.version > entry2.version) {
+                entry2.content = op.payload.newContent;
+                entry2.version = op.payload.version;
+                entry2.editedAt = op.ts;
+              }
+            } else if (op.kind === "remove") {
+              const entry2 = state.byId[op.entryId];
+              if (entry2 && !entry2.removedAt) {
+                entry2.removedAt = op.ts;
+              }
+            } else if (op.kind === "reaction") {
+              if (op.sender.info) {
+                state.participantCache[op.sender.id] = op.sender.info;
+              }
+              const entry2 = state.byId[op.entryId];
+              if (entry2) {
+                applyReactionToEntry(
+                  entry2,
+                  op.payload.emoji,
+                  op.sender.id,
+                  op.payload.op
+                );
+              }
+            }
+          }
+        }
+      } else if (envelope.kind === "edit") {
+        const entry = state.byId[envelope.entryId];
+        if (entry) {
+          if (envelope.payload.version > entry.version) {
+            entry.content = envelope.payload.newContent;
+            entry.version = envelope.payload.version;
+            entry.editedAt = envelope.ts;
+          }
+        } else {
+          if (!state.pendingOps[envelope.entryId]) {
+            state.pendingOps[envelope.entryId] = [];
+          }
+          state.pendingOps[envelope.entryId]?.push(envelope);
+        }
+      } else if (envelope.kind === "remove") {
+        const entry = state.byId[envelope.entryId];
+        if (entry) {
+          if (!entry.removedAt) {
+            entry.removedAt = envelope.ts;
+          }
+        } else {
+          if (!state.pendingOps[envelope.entryId]) {
+            state.pendingOps[envelope.entryId] = [];
+          }
+          state.pendingOps[envelope.entryId]?.push(envelope);
+        }
+      } else if (envelope.kind === "reaction") {
+        if (envelope.sender.info) {
+          state.participantCache[envelope.sender.id] = envelope.sender.info;
+        }
+        const entry = state.byId[envelope.entryId];
+        if (entry) {
+          applyReactionToEntry(
+            entry,
+            envelope.payload.emoji,
+            envelope.sender.id,
+            envelope.payload.op
+          );
+        } else {
+          if (!state.pendingOps[envelope.entryId]) {
+            state.pendingOps[envelope.entryId] = [];
+          }
+          state.pendingOps[envelope.entryId]?.push(envelope);
+        }
+      }
+    }),
+    addFile: (file, filename) => set((state) => {
+      const values = Object.values(state.byId);
+      const entryArr = values.filter((val) => val.filename === filename);
+      const entry = entryArr[0];
+      entry.file = file;
+      state.byId[entry.id] = entry;
+    }),
+    addEntryOptimistic: (entry) => set((state) => {
+      state.byId[entry.id] = entry;
+      state.order.push(entry.id);
+      trimEntriesIfNeeded(state);
+    }),
+    markEntrySent: (entryId) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry) {
+        entry.status = "sent";
+      }
+    }),
+    markEntryFailed: (entryId) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry) {
+        entry.status = "failed";
+      }
+    }),
+    applyEdit: (entryId, newContent, version) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry && version > entry.version) {
+        entry.content = newContent;
+        entry.version = version;
+        entry.editedAt = Date.now();
+      }
+    }),
+    applyRemove: (entryId) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry && !entry.removedAt) {
+        entry.removedAt = Date.now();
+      }
+    }),
+    applyReaction: (entryId, emoji, participantId, op) => set((state) => {
+      const entry = state.byId[entryId];
+      if (entry) {
+        applyReactionToEntry(entry, emoji, participantId, op);
+      }
+    }),
+    queuePendingOp: (entryId, envelope) => set((state) => {
+      if (!state.pendingOps[entryId]) {
+        state.pendingOps[entryId] = [];
+      }
+      state.pendingOps[entryId].push(envelope);
+    }),
+    processPendingOps: (entryId) => set((state) => {
+      const pendingOps = state.pendingOps[entryId];
+      if (!pendingOps) {
+        return;
+      }
+      delete state.pendingOps[entryId];
+      for (const envelope of pendingOps) {
+        if (envelope.kind === "edit") {
+          const entry = state.byId[envelope.entryId];
+          if (entry && envelope.payload.version > entry.version) {
+            entry.content = envelope.payload.newContent;
+            entry.version = envelope.payload.version;
+            entry.editedAt = envelope.ts;
+          }
+        } else if (envelope.kind === "remove") {
+          const entry = state.byId[envelope.entryId];
+          if (entry && !entry.removedAt) {
+            entry.removedAt = envelope.ts;
+          }
+        } else if (envelope.kind === "reaction") {
+          if (envelope.sender.info) {
+            state.participantCache[envelope.sender.id] = envelope.sender.info;
+          }
+          const entry = state.byId[envelope.entryId];
+          if (entry) {
+            applyReactionToEntry(
+              entry,
+              envelope.payload.emoji,
+              envelope.sender.id,
+              envelope.payload.op
+            );
+          }
+        }
+      }
+    }),
+    trimOldEntries: () => set((state) => {
+      trimEntriesIfNeeded(state);
+    }),
+    clearChat: () => set(() => defaultChatState)
+  }))
+);
+var defaultState2 = {
+  raisedHands: /* @__PURE__ */ new Map(),
+  nextOrder: 1
+};
+var useRaiseHandStore = zustand.create()(
+  immer.immer((set, get) => ({
+    ...defaultState2,
+    raiseHand: (participantId) => set((state) => {
+      if (!state.raisedHands.has(participantId)) {
+        state.raisedHands.set(participantId, {
+          ts: Date.now(),
+          order: state.nextOrder++
+        });
+      }
+    }),
+    lowerHand: (participantId) => set((state) => {
+      state.raisedHands.delete(participantId);
+      if (state.raisedHands.size === 0) {
+        state.nextOrder = 1;
+      }
+    }),
+    lowerAllHands: () => set((state) => {
+      state.raisedHands.clear();
+      state.nextOrder = 1;
+    }),
+    isHandRaised: (participantId) => get().raisedHands.has(participantId),
+    getRaisedHandOrder: (participantId) => {
+      const hand = get().raisedHands.get(participantId);
+      return hand?.order ?? null;
+    },
+    upsertParticipantInfo: (id, info) => {
+    },
+    clear: () => set(() => ({
+      raisedHands: /* @__PURE__ */ new Map(),
+      nextOrder: 1
+    }))
+  }))
+);
+var defaultState3 = {
+  spotlightedUser: null,
+  isSpotlighted: false
+};
+var useSpotlightStore = zustand.create()(
+  immer.immer((set, get) => ({
+    ...defaultState3,
+    spotlight: (participantId, info) => set((state) => {
+      state.spotlightedUser = {
+        participantId,
+        ts: Date.now(),
+        ...info && { info }
+      };
+      state.isSpotlighted = true;
+    }),
+    unspotlight: () => set((state) => {
+      state.spotlightedUser = null;
+      state.isSpotlighted = false;
+    }),
+    getSpotlightedUser: () => get().spotlightedUser,
+    clear: () => set(() => ({
+      spotlightedUser: null,
+      isSpotlighted: false
+    }))
+  }))
+);
 
 // src/state/errors.ts
 function pushError(code, message, context, logger7) {
@@ -1591,13 +1887,13 @@ var useProfileCache = zustand.create()(
   }))
 );
 var profileCache = useProfileCache;
-var defaultState2 = {
+var defaultState4 = {
   recording: null,
   isRecording: false
 };
 var useRecordingStore = zustand.create()(
   immer.immer((set) => ({
-    ...defaultState2,
+    ...defaultState4,
     setRecording: (recording) => set((state) => {
       state.recording = recording;
       state.isRecording = recording !== null;
@@ -1690,6 +1986,9 @@ var SessionEndedHandler = class extends BaseSocketHandler {
     rtcStore.getState().reset();
     profileCache.getState().clear();
     recordingStore.getState().clear();
+    useChatStore.getState().clearChat();
+    useSpotlightStore.getState().clear();
+    useRaiseHandStore.getState().clear();
     if (this.livekit) {
       this.livekit.disconnect().catch((error) => {
         this.logger.error("Error disconnecting from LiveKit", { error });
@@ -2621,6 +2920,9 @@ function createCallsService(config, deps) {
         rtcStore.getState().reset();
         profileCache.getState().clear();
         recordingStore.getState().clear();
+        useChatStore.getState().clearChat();
+        useSpotlightStore.getState().clear();
+        useRaiseHandStore.getState().clear();
       }
     } catch (error) {
       rtcStore.getState().addError({
@@ -2702,6 +3004,9 @@ function createCallsService(config, deps) {
       rtcStore.getState().reset();
       profileCache.getState().clear();
       recordingStore.getState().clear();
+      useChatStore.getState().clearChat();
+      useSpotlightStore.getState().clear();
+      useRaiseHandStore.getState().clear();
       return response;
     } catch (error) {
       rtcStore.getState().addError({
@@ -3476,50 +3781,12 @@ function useTerminate() {
     isInitiator
   };
 }
-var defaultState3 = {
-  raisedHands: /* @__PURE__ */ new Map(),
-  nextOrder: 1
-};
-var useRaiseHandStore = zustand.create()(
-  immer.immer((set, get) => ({
-    ...defaultState3,
-    raiseHand: (participantId) => set((state) => {
-      if (!state.raisedHands.has(participantId)) {
-        state.raisedHands.set(participantId, {
-          ts: Date.now(),
-          order: state.nextOrder++
-        });
-      }
-    }),
-    lowerHand: (participantId) => set((state) => {
-      state.raisedHands.delete(participantId);
-      if (state.raisedHands.size === 0) {
-        state.nextOrder = 1;
-      }
-    }),
-    lowerAllHands: () => set((state) => {
-      state.raisedHands.clear();
-      state.nextOrder = 1;
-    }),
-    isHandRaised: (participantId) => get().raisedHands.has(participantId),
-    getRaisedHandOrder: (participantId) => {
-      const hand = get().raisedHands.get(participantId);
-      return hand?.order ?? null;
-    },
-    upsertParticipantInfo: (id, info) => {
-    },
-    clear: () => set(() => ({
-      raisedHands: /* @__PURE__ */ new Map(),
-      nextOrder: 1
-    }))
-  }))
-);
-var defaultState4 = {
+var defaultState5 = {
   pinnedParticipantIds: /* @__PURE__ */ new Set()
 };
 var useParticipantListStore = zustand.create()(
   immer.immer((set, get) => ({
-    ...defaultState4,
+    ...defaultState5,
     togglePin: (participantId) => set((state) => {
       if (state.pinnedParticipantIds.has(participantId)) {
         state.pinnedParticipantIds.delete(participantId);