vg-x07df 1.8.1 → 1.8.3

package/dist/channel/index.cjs

@@ -468,37 +468,29 @@ var ChatService = class {
     this.room.registerTextStreamHandler(
       "chat:v1",
       async (reader, participantInfo) => {
-        console.log("Got here: chat:v1", participantInfo.identity);
         try {
           const text = await reader.readAll();
-          console.log("Got here: chat:v1", text);
+          console.log("Got here: chat:v1", text, participantInfo.identity);
           this.handleIncomingMessage(text);
         } catch (error) {
           logger.error("Error reading text stream", error);
         }
       }
     );
-    this.room.registerByteStreamHandler("chat:v1", async (reader, participantInfo) => {
-      try {
-        const info = reader.info;
-        const filename = info.name;
-        reader.onProgress = (progress) => {
-          console.log(`${progress ? (progress * 100).toFixed(0) : "undefined"}% of ${filename} downloaded`);
-        };
-        const parts = (await reader.readAll()).map((chunk) => chunk.slice());
-        const fileBlob = new Blob(parts, { type: info.mimeType });
-        this.handleIncomingFile(fileBlob, filename, info.mimeType);
-        console.log(
-          `File "${info.name}" received from ${participantInfo.identity}
-  Topic: ${info.topic}
-  Timestamp: ${info.timestamp}
-  ID: ${info.id}
-  Size: ${info.size}`
-        );
-      } catch (error) {
-        logger.error("Error reading file stream", error);
+    this.room.registerByteStreamHandler(
+      "chat:v1",
+      async (reader, participantInfo) => {
+        try {
+          const info = reader.info;
+          const filename = info.name;
+          const parts = (await reader.readAll()).map((chunk) => chunk.slice());
+          const fileBlob = new Blob(parts, { type: info.mimeType });
+          this.handleIncomingFile(fileBlob, filename, info.mimeType);
+        } catch (error) {
+          logger.error("Error reading file stream", error);
+        }
       }
-    });
+    );
     this.isSubscribed = true;
   }
   unsubscribe() {
@@ -517,7 +509,6 @@ var ChatService = class {
       return;
     }
     if (content.length === 0 && typeof file !== "undefined") {
-      console.log("file present", typeof file);
       content = file.name;
     }
     const validation = validateContent(content);
@@ -566,7 +557,6 @@ var ChatService = class {
       await this.room.localParticipant.sendText(JSON.stringify(envelope), {
         topic: "chat:v1"
       });
-      console.log("Sent message", entry, envelope);
       if (file) {
         await this.room.localParticipant.sendFile(file, {
           mimeType: file.type,
@@ -881,13 +871,313 @@ function useChat() {
   };
 }
 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
+    }))
+  }))
+);
+function applyIncomingRaiseHand(envelope) {
+  const { raiseHand, lowerHand, lowerAllHands, upsertParticipantInfo } = useRaiseHandStore.getState();
+  if (envelope.sender.info) {
+    upsertParticipantInfo(envelope.sender.id, envelope.sender.info);
+  }
+  switch (envelope.payload.action) {
+    case "raise": {
+      raiseHand(envelope.sender.id);
+      break;
+    }
+    case "lower": {
+      const targetId = envelope.payload.targetId || envelope.sender.id;
+      lowerHand(targetId);
+      break;
+    }
+    case "lower-all": {
+      lowerAllHands();
+      break;
+    }
+  }
+}
+
+// src/channel/raiseHand/service.ts
+var logger2 = createLogger("raise-hand");
+var RaiseHandService = class {
+  constructor(room) {
+    this.isSubscribed = false;
+    this.room = room;
+  }
+  isRoomReady() {
+    if (!this.room) {
+      logger2.warn("Room not initialized");
+      return false;
+    }
+    if (this.room.state !== livekitClient.ConnectionState.Connected) {
+      logger2.warn("Room not connected", { state: this.room.state });
+      return false;
+    }
+    if (!this.room.localParticipant) {
+      logger2.warn("Local participant not available");
+      return false;
+    }
+    return true;
+  }
+  subscribe() {
+    if (this.isSubscribed) return;
+    this.room.registerTextStreamHandler("raise-hand:v1", async (reader) => {
+      try {
+        const text = await reader.readAll();
+        this.handleIncoming(text);
+      } catch (err) {
+        logger2.error("Error reading raise-hand stream", err);
+      }
+    });
+    this.isSubscribed = true;
+    logger2.info("RaiseHandService subscribed");
+  }
+  unsubscribe() {
+    this.isSubscribed = false;
+    logger2.info("RaiseHandService unsubscribed");
+  }
+  getLocalParticipantId() {
+    return this.room.localParticipant.identity;
+  }
+  async raiseHand() {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "RAISE_HAND_ROOM_NOT_READY",
+        message: "Cannot raise hand: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    useRaiseHandStore.getState().raiseHand(senderInfo.id);
+    try {
+      const envelope = {
+        v: 1,
+        kind: "raise-hand",
+        roomId: this.room.name,
+        ts: Date.now(),
+        sender: senderInfo,
+        payload: {
+          action: "raise"
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "raise-hand:v1"
+      });
+      logger2.debug("Hand raised");
+    } catch (error) {
+      logger2.error("Failed to raise hand", error);
+      useRtcStore.getState().addError({
+        code: "RAISE_HAND_SEND_FAILED",
+        message: error instanceof Error ? error.message : "Failed to raise hand",
+        timestamp: Date.now()
+      });
+    }
+  }
+  async lowerHand(targetId) {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "LOWER_HAND_ROOM_NOT_READY",
+        message: "Cannot lower hand: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    const participantId = targetId || senderInfo.id;
+    useRaiseHandStore.getState().lowerHand(participantId);
+    try {
+      const envelope = {
+        v: 1,
+        kind: "raise-hand",
+        roomId: this.room.name,
+        ts: Date.now(),
+        sender: senderInfo,
+        payload: {
+          action: "lower",
+          targetId: participantId
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "raise-hand:v1"
+      });
+      logger2.debug("Hand lowered", { targetId: participantId });
+    } catch (error) {
+      logger2.error("Failed to lower hand", error);
+      useRtcStore.getState().addError({
+        code: "LOWER_HAND_SEND_FAILED",
+        message: error instanceof Error ? error.message : "Failed to lower hand",
+        timestamp: Date.now()
+      });
+    }
+  }
+  async lowerAllHands() {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "LOWER_ALL_HANDS_ROOM_NOT_READY",
+        message: "Cannot lower all hands: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    useRaiseHandStore.getState().lowerAllHands();
+    try {
+      const envelope = {
+        v: 1,
+        kind: "raise-hand",
+        roomId: this.room.name,
+        ts: Date.now(),
+        sender: senderInfo,
+        payload: {
+          action: "lower-all"
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "raise-hand:v1"
+      });
+      logger2.debug("All hands lowered");
+    } catch (error) {
+      logger2.error("Failed to lower all hands", error);
+      useRtcStore.getState().addError({
+        code: "LOWER_ALL_HANDS_SEND_FAILED",
+        message: error instanceof Error ? error.message : "Failed to lower all hands",
+        timestamp: Date.now()
+      });
+    }
+  }
+  handleIncoming(text) {
+    try {
+      const parsed = JSON.parse(text);
+      if (!this.isValidEnvelope(parsed)) {
+        logger2.warn("Invalid raise-hand envelope received", parsed);
+        return;
+      }
+      if (parsed.sender.id === this.getLocalParticipantId()) {
+        logger2.debug("Ignoring self-echo raise-hand message");
+        return;
+      }
+      applyIncomingRaiseHand(parsed);
+      logger2.debug("Raise-hand message received", {
+        action: parsed.payload.action
+      });
+    } catch (error) {
+      logger2.error("Error parsing incoming raise-hand message", error);
+    }
+  }
+  isValidEnvelope(e) {
+    return e && e.v === 1 && e.kind === "raise-hand" && typeof e.roomId === "string" && e.roomId === this.room.name && typeof e.ts === "number" && e.ts > 0 && typeof e.sender?.id === "string" && typeof e.payload?.action === "string" && ["raise", "lower", "lower-all"].includes(e.payload.action);
+  }
+  getSenderInfo() {
+    const localParticipant = this.room.localParticipant;
+    const sender = {
+      id: localParticipant.identity
+    };
+    if (localParticipant.metadata) {
+      try {
+        sender.info = JSON.parse(
+          localParticipant.metadata
+        );
+      } catch {
+      }
+    }
+    return sender;
+  }
+};
+var logger3 = createLogger("raise-hand:hook");
+function useRaiseHand() {
+  const service = useFeatureService("raise-hand");
+  const raisedHands = useRaiseHandStore((state) => state.raisedHands);
+  const isHandRaised = useRaiseHandStore((state) => state.isHandRaised);
+  const getRaisedHandOrder = useRaiseHandStore(
+    (state) => state.getRaisedHandOrder
+  );
+  const raiseHand = react.useCallback(async () => {
+    if (!service) {
+      logger3.error("Cannot raise hand: service not ready");
+      return;
+    }
+    return service.raiseHand();
+  }, [service]);
+  const lowerHand = react.useCallback(
+    async (participantId) => {
+      if (!service) {
+        logger3.error("Cannot lower hand: service not ready");
+        return;
+      }
+      return service.lowerHand(participantId);
+    },
+    [service]
+  );
+  const lowerAllHands = react.useCallback(async () => {
+    if (!service) {
+      logger3.error("Cannot lower all hands: service not ready");
+      return;
+    }
+    return service.lowerAllHands();
+  }, [service]);
+  const getRaisedHands = react.useCallback(() => {
+    const hands = [];
+    for (const [participantId, hand] of raisedHands.entries()) {
+      hands.push({
+        participantId,
+        order: hand.order,
+        ts: hand.ts
+      });
+    }
+    return hands.sort((a, b) => a.order - b.order);
+  }, [raisedHands]);
+  return {
+    raiseHand,
+    lowerHand,
+    lowerAllHands,
+    isHandRaised,
+    getRaisedHandOrder,
+    getRaisedHands,
+    isReady: !!service
+  };
+}
+var defaultState3 = {
   reactions: /* @__PURE__ */ new Map(),
   participantCache: {},
   ttlMs: 4e3
 };
 var useReactionsStore = zustand.create()(
   immer.immer((set) => ({
-    ...defaultState2,
+    ...defaultState3,
     setReaction: (participantId, reaction) => set((state) => {
       state.reactions.set(participantId, reaction);
     }),
@@ -908,7 +1198,7 @@ var useReactionsStore = zustand.create()(
     clear: () => set(() => ({
       reactions: /* @__PURE__ */ new Map(),
       participantCache: {},
-      ttlMs: defaultState2.ttlMs
+      ttlMs: defaultState3.ttlMs
     }))
   }))
 );
@@ -940,7 +1230,7 @@ function generateNonce() {
 }
 
 // src/channel/reactions/service.ts
-var logger3 = createLogger("reactions");
+var logger5 = createLogger("reactions");
 var ReactionsService = class {
   constructor(room) {
     this.isSubscribed = false;
@@ -951,15 +1241,15 @@ var ReactionsService = class {
   }
   isRoomReady() {
     if (!this.room) {
-      logger3.warn("Room not initialized");
+      logger5.warn("Room not initialized");
       return false;
     }
     if (this.room.state !== livekitClient.ConnectionState.Connected) {
-      logger3.warn("Room not connected", { state: this.room.state });
+      logger5.warn("Room not connected", { state: this.room.state });
       return false;
     }
     if (!this.room.localParticipant) {
-      logger3.warn("Local participant not available");
+      logger5.warn("Local participant not available");
       return false;
     }
     return true;
@@ -977,14 +1267,14 @@ var ReactionsService = class {
         const text = await reader.readAll();
         this.handleIncoming(text);
       } catch (err) {
-        logger3.error("Error reading reactions stream", err);
+        logger5.error("Error reading reactions stream", err);
       }
     });
     this.pruneInterval = setInterval(() => {
       useReactionsStore.getState().pruneExpired();
     }, 1e3);
     this.isSubscribed = true;
-    logger3.info("ReactionsService subscribed");
+    logger5.info("ReactionsService subscribed");
   }
   unsubscribe() {
     this.isSubscribed = false;
@@ -992,7 +1282,7 @@ var ReactionsService = class {
       clearInterval(this.pruneInterval);
       this.pruneInterval = void 0;
     }
-    logger3.info("ReactionsService unsubscribed");
+    logger5.info("ReactionsService unsubscribed");
   }
   getLocalParticipantId() {
     return this.room.localParticipant.identity;
@@ -1016,7 +1306,7 @@ var ReactionsService = class {
       return;
     }
     if (!this.canSendNow()) {
-      logger3.debug("Rate limited, skipping send");
+      logger5.debug("Rate limited, skipping send");
       return;
     }
     const senderInfo = this.getSenderInfo();
@@ -1042,9 +1332,9 @@ var ReactionsService = class {
       await this.room.localParticipant.sendText(JSON.stringify(envelope), {
         topic: "reactions:v1"
       });
-      logger3.debug("Reaction sent", { emoji });
+      logger5.debug("Reaction sent", { emoji });
     } catch (error) {
-      logger3.error("Failed to send reaction", error);
+      logger5.error("Failed to send reaction", error);
       useRtcStore.getState().addError({
         code: "REACTIONS_SEND_FAILED",
         message: error instanceof Error ? error.message : "Failed to send reaction",
@@ -1057,16 +1347,16 @@ var ReactionsService = class {
     try {
       const parsed = JSON.parse(text);
       if (!this.isValidEnvelope(parsed)) {
-        logger3.warn("Invalid reaction envelope received", parsed);
+        logger5.warn("Invalid reaction envelope received", parsed);
         return;
       }
       if (parsed.sender.id === this.getLocalParticipantId()) {
-        logger3.debug("Ignoring self-echo reaction");
+        logger5.debug("Ignoring self-echo reaction");
         return;
       }
       const lastTs = this.lastRemoteTs.get(parsed.sender.id) ?? Number.NEGATIVE_INFINITY;
       if (parsed.ts < lastTs) {
-        logger3.debug("Ignoring out-of-order reaction", {
+        logger5.debug("Ignoring out-of-order reaction", {
           sender: parsed.sender.id,
           ts: parsed.ts,
           lastTs
@@ -1075,9 +1365,9 @@ var ReactionsService = class {
       }
       this.lastRemoteTs.set(parsed.sender.id, parsed.ts);
       applyIncomingReaction(parsed);
-      logger3.debug("Reaction received", { emoji: parsed.payload.emoji });
+      logger5.debug("Reaction received", { emoji: parsed.payload.emoji });
     } catch (error) {
-      logger3.error("Error parsing incoming reaction", error);
+      logger5.error("Error parsing incoming reaction", error);
     }
   }
   isValidEnvelope(e) {
@@ -1099,7 +1389,7 @@ var ReactionsService = class {
     return sender;
   }
 };
-var logger4 = createLogger("reactions:hook");
+var logger6 = createLogger("reactions:hook");
 function useReactions() {
   const service = useFeatureService("reactions");
   const reactions = useReactionsStore((state) => state.reactions);
@@ -1118,7 +1408,7 @@ function useReactions() {
   const sendReaction = react.useCallback(
     async (emoji) => {
       if (!service) {
-        logger4.error("Cannot send reaction: service not ready");
+        logger6.error("Cannot send reaction: service not ready");
         return;
       }
       return service.sendReaction(emoji);
@@ -1148,10 +1438,15 @@ var FEATURES = {
     name: "reactions",
     createService: (room) => new ReactionsService(room),
     cleanupStore: () => useReactionsStore.getState().clear()
+  },
+  "raise-hand": {
+    name: "raise-hand",
+    createService: (room) => new RaiseHandService(room),
+    cleanupStore: () => useRaiseHandStore.getState().clear()
   }
 };
-var DEFAULT_FEATURES = ["chat", "reactions"];
-var logger5 = createLogger("channels:provider");
+var DEFAULT_FEATURES = ["chat", "reactions", "raise-hand"];
+var logger7 = createLogger("channels:provider");
 function DataChannelProvider({
   room,
   features = DEFAULT_FEATURES,
@@ -1161,52 +1456,52 @@ function DataChannelProvider({
   const [isReady, setIsReady] = react.useState(false);
   react.useEffect(() => {
     if (!room) {
-      logger5.warn("DataChannelProvider mounted without room");
+      logger7.warn("DataChannelProvider mounted without room");
       return;
     }
-    logger5.debug("Initializing features", { features });
+    logger7.debug("Initializing features", { features });
     for (const featureName of features) {
       const feature = FEATURES[featureName];
       if (!feature) {
-        logger5.warn(`Feature "${featureName}" not found in registry`);
+        logger7.warn(`Feature "${featureName}" not found in registry`);
         continue;
       }
       try {
-        logger5.debug(`Initializing feature: ${featureName}`);
+        logger7.debug(`Initializing feature: ${featureName}`);
         const service = feature.createService(room);
         service.subscribe();
         services.current.set(featureName, service);
-        logger5.info(`Feature "${featureName}" initialized`);
+        logger7.info(`Feature "${featureName}" initialized`);
       } catch (error) {
-        logger5.error(`Failed to initialize feature "${featureName}"`, error);
+        logger7.error(`Failed to initialize feature "${featureName}"`, error);
       }
     }
     setIsReady(true);
-    logger5.info("All features initialized");
+    logger7.info("All features initialized");
     return () => {
-      logger5.debug("Cleaning up features");
+      logger7.debug("Cleaning up features");
       services.current.forEach((service, name) => {
         try {
-          logger5.debug(`Unsubscribing feature: ${name}`);
+          logger7.debug(`Unsubscribing feature: ${name}`);
           service.unsubscribe();
         } catch (error) {
-          logger5.error(`Failed to unsubscribe feature "${name}"`, error);
+          logger7.error(`Failed to unsubscribe feature "${name}"`, error);
         }
       });
       for (const featureName of features) {
         const feature = FEATURES[featureName];
         if (feature?.cleanupStore) {
           try {
-            logger5.debug(`Cleaning store for feature: ${featureName}`);
+            logger7.debug(`Cleaning store for feature: ${featureName}`);
             feature.cleanupStore();
           } catch (error) {
-            logger5.error(`Failed to cleanup store for "${featureName}"`, error);
+            logger7.error(`Failed to cleanup store for "${featureName}"`, error);
           }
         }
       }
       services.current.clear();
       setIsReady(false);
-      logger5.info("Features cleanup complete");
+      logger7.info("Features cleanup complete");
     };
   }, [room, features]);
   const contextValue = react.useMemo(
@@ -1221,6 +1516,7 @@ function DataChannelProvider({
 
 exports.ChatService = ChatService;
 exports.DataChannelProvider = DataChannelProvider;
+exports.RaiseHandService = RaiseHandService;
 exports.ReactionsService = ReactionsService;
 exports.applyIncomingReaction = applyIncomingReaction;
 exports.compareEntries = compareEntries;
@@ -1232,6 +1528,8 @@ exports.useChat = useChat;
 exports.useChatStore = useChatStore;
 exports.useDataChannelContext = useDataChannelContext;
 exports.useFeatureService = useFeatureService;
+exports.useRaiseHand = useRaiseHand;
+exports.useRaiseHandStore = useRaiseHandStore;
 exports.useReactions = useReactions;
 exports.useReactionsStore = useReactionsStore;
 exports.validateContent = validateContent;