vg-x07df 1.8.3 → 1.9.0

package/dist/channel/index.cjs

@@ -508,10 +508,8 @@ var ChatService = class {
       });
       return;
     }
-    if (content.length === 0 && typeof file !== "undefined") {
-      content = file.name;
-    }
-    const validation = validateContent(content);
+    const messageContent = content.length === 0 && typeof file !== "undefined" ? file.name : content;
+    const validation = validateContent(messageContent);
     if (!validation.valid) {
       useRtcStore.getState().addError({
         code: "CHAT_INVALID_CONTENT",
@@ -530,7 +528,7 @@ var ChatService = class {
     }
     const entry = {
       id: entryId,
-      content,
+      content: messageContent,
       sender: {
         id: senderInfo.id
       },
@@ -1426,6 +1424,236 @@ function useReactions() {
     isReady: !!service
   };
 }
+var defaultState4 = {
+  spotlightedUser: null
+};
+var useSpotlightStore = zustand.create()(
+  immer.immer((set, get) => ({
+    ...defaultState4,
+    spotlight: (participantId, info) => set((state) => {
+      state.spotlightedUser = {
+        participantId,
+        ts: Date.now(),
+        ...info && { info }
+      };
+    }),
+    unspotlight: () => set((state) => {
+      state.spotlightedUser = null;
+    }),
+    getSpotlightedUser: () => get().spotlightedUser,
+    isSpotlighted: (participantId) => {
+      const user = get().spotlightedUser;
+      return user?.participantId === participantId;
+    },
+    clear: () => set(() => ({
+      spotlightedUser: null
+    }))
+  }))
+);
+function applyIncomingSpotlight(envelope) {
+  const { spotlight, unspotlight } = useSpotlightStore.getState();
+  switch (envelope.payload.action) {
+    case "spotlight": {
+      spotlight(envelope.payload.targetId);
+      break;
+    }
+    case "unspotlight": {
+      unspotlight();
+      break;
+    }
+  }
+}
+
+// src/channel/spotlight/service.ts
+var logger7 = createLogger("spotlight");
+var SpotlightService = class {
+  constructor(room) {
+    this.isSubscribed = false;
+    this.room = room;
+  }
+  isRoomReady() {
+    if (!this.room) {
+      logger7.warn("Room not initialized");
+      return false;
+    }
+    if (this.room.state !== livekitClient.ConnectionState.Connected) {
+      logger7.warn("Room not connected", { state: this.room.state });
+      return false;
+    }
+    if (!this.room.localParticipant) {
+      logger7.warn("Local participant not available");
+      return false;
+    }
+    return true;
+  }
+  subscribe() {
+    if (this.isSubscribed) return;
+    this.room.registerTextStreamHandler("spotlight:v1", async (reader) => {
+      try {
+        const text = await reader.readAll();
+        this.handleIncoming(text);
+      } catch (err) {
+        logger7.error("Error reading spotlight stream", err);
+      }
+    });
+    this.isSubscribed = true;
+    logger7.info("SpotlightService subscribed");
+  }
+  unsubscribe() {
+    this.isSubscribed = false;
+    logger7.info("SpotlightService unsubscribed");
+  }
+  getLocalParticipantId() {
+    return this.room.localParticipant.identity;
+  }
+  async spotlight(targetId) {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "SPOTLIGHT_ROOM_NOT_READY",
+        message: "Cannot spotlight: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    useSpotlightStore.getState().spotlight(targetId);
+    try {
+      const envelope = {
+        v: 1,
+        kind: "spotlight",
+        roomId: this.room.name,
+        ts: Date.now(),
+        sender: senderInfo,
+        payload: {
+          action: "spotlight",
+          targetId
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "spotlight:v1"
+      });
+      logger7.debug("User spotlighted", { targetId });
+    } catch (error) {
+      logger7.error("Failed to spotlight user", error);
+      useRtcStore.getState().addError({
+        code: "SPOTLIGHT_SEND_FAILED",
+        message: error instanceof Error ? error.message : "Failed to spotlight user",
+        timestamp: Date.now()
+      });
+    }
+  }
+  async unspotlight() {
+    if (!this.isRoomReady()) {
+      useRtcStore.getState().addError({
+        code: "UNSPOTLIGHT_ROOM_NOT_READY",
+        message: "Cannot unspotlight: room not connected",
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const senderInfo = this.getSenderInfo();
+    const currentSpotlighted = useSpotlightStore.getState().getSpotlightedUser();
+    if (!currentSpotlighted) {
+      logger7.debug("No user is currently spotlighted");
+      return;
+    }
+    useSpotlightStore.getState().unspotlight();
+    try {
+      const envelope = {
+        v: 1,
+        kind: "spotlight",
+        roomId: this.room.name,
+        ts: Date.now(),
+        sender: senderInfo,
+        payload: {
+          action: "unspotlight",
+          targetId: currentSpotlighted.participantId
+        }
+      };
+      await this.room.localParticipant.sendText(JSON.stringify(envelope), {
+        topic: "spotlight:v1"
+      });
+      logger7.debug("User unspotlighted");
+    } catch (error) {
+      logger7.error("Failed to unspotlight user", error);
+      useRtcStore.getState().addError({
+        code: "UNSPOTLIGHT_SEND_FAILED",
+        message: error instanceof Error ? error.message : "Failed to unspotlight user",
+        timestamp: Date.now()
+      });
+    }
+  }
+  handleIncoming(text) {
+    try {
+      const parsed = JSON.parse(text);
+      if (!this.isValidEnvelope(parsed)) {
+        logger7.warn("Invalid spotlight envelope received", parsed);
+        return;
+      }
+      if (parsed.sender.id === this.getLocalParticipantId()) {
+        logger7.debug("Ignoring self-echo spotlight message");
+        return;
+      }
+      applyIncomingSpotlight(parsed);
+      logger7.debug("Spotlight message received", {
+        action: parsed.payload.action,
+        targetId: parsed.payload.targetId
+      });
+    } catch (error) {
+      logger7.error("Error parsing incoming spotlight message", error);
+    }
+  }
+  isValidEnvelope(e) {
+    return e && e.v === 1 && e.kind === "spotlight" && 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" && ["spotlight", "unspotlight"].includes(e.payload.action) && typeof e.payload?.targetId === "string";
+  }
+  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 logger8 = createLogger("spotlight:hook");
+function useSpotlight() {
+  const service = useFeatureService("spotlight");
+  const getSpotlightedUser = useSpotlightStore(
+    (state) => state.getSpotlightedUser
+  );
+  const isSpotlighted = useSpotlightStore((state) => state.isSpotlighted);
+  const spotlight = react.useCallback(
+    async (targetId) => {
+      if (!service) {
+        logger8.error("Cannot spotlight: service not ready");
+        return;
+      }
+      return service.spotlight(targetId);
+    },
+    [service]
+  );
+  const unspotlight = react.useCallback(async () => {
+    if (!service) {
+      logger8.error("Cannot unspotlight: service not ready");
+      return;
+    }
+    return service.unspotlight();
+  }, [service]);
+  return {
+    spotlight,
+    unspotlight,
+    getSpotlightedUser,
+    isSpotlighted,
+    isReady: !!service
+  };
+}
 
 // src/channel/registry.ts
 var FEATURES = {
@@ -1443,10 +1671,15 @@ var FEATURES = {
     name: "raise-hand",
     createService: (room) => new RaiseHandService(room),
     cleanupStore: () => useRaiseHandStore.getState().clear()
+  },
+  spotlight: {
+    name: "spotlight",
+    createService: (room) => new SpotlightService(room),
+    cleanupStore: () => useSpotlightStore.getState().clear()
   }
 };
-var DEFAULT_FEATURES = ["chat", "reactions", "raise-hand"];
-var logger7 = createLogger("channels:provider");
+var DEFAULT_FEATURES = ["chat", "reactions", "raise-hand", "spotlight"];
+var logger9 = createLogger("channels:provider");
 function DataChannelProvider({
   room,
   features = DEFAULT_FEATURES,
@@ -1456,52 +1689,52 @@ function DataChannelProvider({
   const [isReady, setIsReady] = react.useState(false);
   react.useEffect(() => {
     if (!room) {
-      logger7.warn("DataChannelProvider mounted without room");
+      logger9.warn("DataChannelProvider mounted without room");
       return;
     }
-    logger7.debug("Initializing features", { features });
+    logger9.debug("Initializing features", { features });
     for (const featureName of features) {
       const feature = FEATURES[featureName];
       if (!feature) {
-        logger7.warn(`Feature "${featureName}" not found in registry`);
+        logger9.warn(`Feature "${featureName}" not found in registry`);
         continue;
       }
       try {
-        logger7.debug(`Initializing feature: ${featureName}`);
+        logger9.debug(`Initializing feature: ${featureName}`);
         const service = feature.createService(room);
         service.subscribe();
         services.current.set(featureName, service);
-        logger7.info(`Feature "${featureName}" initialized`);
+        logger9.info(`Feature "${featureName}" initialized`);
       } catch (error) {
-        logger7.error(`Failed to initialize feature "${featureName}"`, error);
+        logger9.error(`Failed to initialize feature "${featureName}"`, error);
       }
     }
     setIsReady(true);
-    logger7.info("All features initialized");
+    logger9.info("All features initialized");
     return () => {
-      logger7.debug("Cleaning up features");
+      logger9.debug("Cleaning up features");
       services.current.forEach((service, name) => {
         try {
-          logger7.debug(`Unsubscribing feature: ${name}`);
+          logger9.debug(`Unsubscribing feature: ${name}`);
           service.unsubscribe();
         } catch (error) {
-          logger7.error(`Failed to unsubscribe feature "${name}"`, error);
+          logger9.error(`Failed to unsubscribe feature "${name}"`, error);
         }
       });
       for (const featureName of features) {
         const feature = FEATURES[featureName];
         if (feature?.cleanupStore) {
           try {
-            logger7.debug(`Cleaning store for feature: ${featureName}`);
+            logger9.debug(`Cleaning store for feature: ${featureName}`);
             feature.cleanupStore();
           } catch (error) {
-            logger7.error(`Failed to cleanup store for "${featureName}"`, error);
+            logger9.error(`Failed to cleanup store for "${featureName}"`, error);
           }
         }
       }
       services.current.clear();
       setIsReady(false);
-      logger7.info("Features cleanup complete");
+      logger9.info("Features cleanup complete");
     };
   }, [room, features]);
   const contextValue = react.useMemo(
@@ -1518,6 +1751,7 @@ exports.ChatService = ChatService;
 exports.DataChannelProvider = DataChannelProvider;
 exports.RaiseHandService = RaiseHandService;
 exports.ReactionsService = ReactionsService;
+exports.SpotlightService = SpotlightService;
 exports.applyIncomingReaction = applyIncomingReaction;
 exports.compareEntries = compareEntries;
 exports.generateEntryId = generateEntryId;
@@ -1532,6 +1766,8 @@ exports.useRaiseHand = useRaiseHand;
 exports.useRaiseHandStore = useRaiseHandStore;
 exports.useReactions = useReactions;
 exports.useReactionsStore = useReactionsStore;
+exports.useSpotlight = useSpotlight;
+exports.useSpotlightStore = useSpotlightStore;
 exports.validateContent = validateContent;
 exports.validateEmoji = validateEmoji;
 //# sourceMappingURL=index.cjs.map