vg-x07df 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # vg-x07df
 
+## 1.3.0
+
+### Minor Changes
+
+- edaed71: Bug fixes
+- 72bb02b: exit
+- 77d4cf4: Peformance and bug fixes
+
 ## 1.0.2
 
 ### Patch Changes

package/dist/index.cjs

@@ -6,8 +6,8 @@ var zustand = require('zustand');
 var immer = require('zustand/middleware/immer');
 var mitt = require('mitt');
 var zod = require('zod');
-var livekitClient = require('livekit-client');
 var componentsReact = require('@livekit/components-react');
+var livekitClient = require('livekit-client');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -164,14 +164,14 @@ var useRtcStore = zustand.create()(
 var rtcStore = useRtcStore;
 
 // src/state/errors.ts
-function pushError(code, message, context, logger4) {
+function pushError(code, message, context, logger5) {
   const error = {
     code,
     message,
     timestamp: Date.now(),
     context
   };
-  logger4?.("error", message, { code, context });
+  logger5?.("error", message, { code, context });
   rtcStore.getState().addError(error);
 }
 function clearErrors(predicate) {
@@ -183,73 +183,73 @@ function clearErrors(predicate) {
     }
   });
 }
-function pushSocketValidationError(eventType, issues, payload, logger4) {
+function pushSocketValidationError(eventType, issues, payload, logger5) {
   pushError(
     "SOCKET_PAYLOAD",
     `Invalid ${eventType} event payload`,
     { eventType, issues, payload },
-    logger4
+    logger5
   );
 }
-function pushIdentityGuardError(reason, expected, received, logger4) {
+function pushIdentityGuardError(reason, expected, received, logger5) {
   pushError(
     "JOIN_FLOW",
     // Use new error code
     `Identity guard failed: ${reason}`,
     { expected, received },
-    logger4
+    logger5
   );
 }
-function pushLiveKitConnectError(message, error, logger4) {
+function pushLiveKitConnectError(message, error, logger5) {
   pushError(
     "LIVEKIT_CONNECT",
     `LiveKit connection failed: ${message}`,
     { originalError: error },
-    logger4
+    logger5
   );
 }
-function pushStaleEventError(eventType, reason, context, logger4) {
+function pushStaleEventError(eventType, reason, context, logger5) {
   pushError(
     "JOIN_FLOW",
     // Use new error code
     `Ignored stale ${eventType} event: ${reason}`,
     context,
-    logger4
+    logger5
   );
 }
-function pushApiError(operation, error, logger4) {
+function pushApiError(operation, error, logger5) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   pushError(
     "API_ERROR",
     `API ${operation} failed: ${errorMessage}`,
     { operation, originalError: error },
-    logger4
+    logger5
   );
 }
-function pushNetworkError(operation, error, logger4) {
+function pushNetworkError(operation, error, logger5) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   pushError(
     "NETWORK",
     `Network error during ${operation}: ${errorMessage}`,
     { operation, originalError: error },
-    logger4
+    logger5
   );
 }
-function pushMediaPermissionError(device, error, logger4) {
+function pushMediaPermissionError(device, error, logger5) {
   pushError(
     "MEDIA_PERMISSION",
     `${device} permission denied`,
     { device, originalError: error },
-    logger4
+    logger5
   );
 }
-function pushDeviceError(operation, device, error, logger4) {
+function pushDeviceError(operation, device, error, logger5) {
   const errorMessage = error instanceof Error ? error.message : String(error);
   pushError(
     "DEVICE_SWITCH",
     `Failed to ${operation} ${device}: ${errorMessage}`,
     { operation, device, originalError: error },
-    logger4
+    logger5
   );
 }
 
@@ -351,18 +351,9 @@ var SdkEventType = /* @__PURE__ */ ((SdkEventType2) => {
   SdkEventType2["CALL_CANCELED"] = "call:canceled";
   SdkEventType2["CALL_TIMEOUT"] = "call:timeout";
   SdkEventType2["JOIN_INFO_RECEIVED"] = "join-info:received";
+  SdkEventType2["CALL_STARTED"] = "call:started";
   SdkEventType2["PARTICIPANT_UPDATED"] = "participant:updated";
   SdkEventType2["PARTICIPANT_INVITED"] = "participant:invited";
-  SdkEventType2["MEDIA_ENABLED"] = "media:enabled";
-  SdkEventType2["MEDIA_DISABLED"] = "media:disabled";
-  SdkEventType2["MEDIA_DEVICE_CHANGED"] = "media:device-changed";
-  SdkEventType2["MEDIA_PERMISSION_GRANTED"] = "media:permission-granted";
-  SdkEventType2["MEDIA_PERMISSION_DENIED"] = "media:permission-denied";
-  SdkEventType2["CONNECTION_ESTABLISHED"] = "connection:established";
-  SdkEventType2["CONNECTION_LOST"] = "connection:lost";
-  SdkEventType2["CONNECTION_RECONNECTING"] = "connection:reconnecting";
-  SdkEventType2["CONNECTION_QUALITY_CHANGED"] = "connection:quality-changed";
-  SdkEventType2["ERROR_OCCURRED"] = "error:occurred";
   return SdkEventType2;
 })(SdkEventType || {});
 var callCancelledSchema = zod.z.object({
@@ -400,7 +391,7 @@ var callEndedSchema = zod.z.object({
 }).strict();
 var callInviteSchema = zod.z.object({
   callId: zod.z.string(),
-  status: zod.z.enum(["pending", "active", "ended"]),
+  status: zod.z.enum(["pending", "ready", "active", "ended"]),
   caller: zod.z.object({
     firstName: zod.z.string().nullable(),
     lastName: zod.z.string().nullable(),
@@ -409,13 +400,11 @@ var callInviteSchema = zod.z.object({
     profilePhoto: zod.z.string().nullable(),
     userId: zod.z.string()
   }).strict(),
-  mode: zod.z.enum(["VIDEO", "AUDIO"]),
-  expiresAt: zod.z.string(),
-  expiresInMs: zod.z.number()
+  mode: zod.z.enum(["VIDEO", "AUDIO"])
 }).strict();
 var callInviteAcceptedSchema = zod.z.object({
   callId: zod.z.string(),
-  status: zod.z.enum(["pending", "active", "ended"]),
+  status: zod.z.enum(["pending", "ready", "active", "ended"]),
   participant: zod.z.object({
     firstName: zod.z.string().nullable(),
     lastName: zod.z.string().nullable(),
@@ -428,14 +417,14 @@ var callInviteAcceptedSchema = zod.z.object({
 }).strict();
 var callInviteCancelledSchema = zod.z.object({
   callId: zod.z.string(),
-  status: zod.z.enum(["pending", "active", "ended"]),
+  status: zod.z.enum(["pending", "ready", "active", "ended"]),
   cancelledByUserId: zod.z.string(),
   cancelledAt: zod.z.string(),
   reason: zod.z.string()
 }).strict();
 var callInviteDeclinedSchema = zod.z.object({
   callId: zod.z.string(),
-  status: zod.z.enum(["pending", "active", "ended"]),
+  status: zod.z.enum(["pending", "ready", "active", "ended"]),
   participant: zod.z.object({
     firstName: zod.z.string().nullable(),
     lastName: zod.z.string().nullable(),
@@ -449,7 +438,7 @@ var callInviteDeclinedSchema = zod.z.object({
 }).strict();
 var callInviteMissedSchema = zod.z.object({
   callId: zod.z.string(),
-  status: zod.z.enum(["pending", "active", "ended"]),
+  status: zod.z.enum(["pending", "ready", "active", "ended"]),
   participant: zod.z.object({
     firstName: zod.z.string().nullable(),
     lastName: zod.z.string().nullable(),
@@ -486,7 +475,7 @@ var callMissedSchema = zod.z.object({
 }).strict();
 var callParticipantAddedSchema = zod.z.object({
   callId: zod.z.string(),
-  status: zod.z.enum(["pending", "active", "ended"]),
+  status: zod.z.enum(["pending", "ready", "active", "ended"]),
   participant: zod.z.object({
     participantId: zod.z.string(),
     userId: zod.z.string(),
@@ -499,6 +488,12 @@ var callParticipantAddedSchema = zod.z.object({
     joinState: zod.z.enum(["not_joined", "joined"])
   }).strict()
 }).strict();
+var callRoomStartedSchema = zod.z.object({
+  callId: zod.z.string(),
+  roomName: zod.z.string(),
+  startedAt: zod.z.string(),
+  status: zod.z.literal("active")
+}).strict();
 
 // src/core/socketio/handlers/invite.handler.ts
 var InviteHandler = class extends BaseSocketHandler {
@@ -524,9 +519,7 @@ var InviteHandler = class extends BaseSocketHandler {
           email: data.caller.email,
           profilePhoto: data.caller.profilePhoto
         },
-        mode: data.mode,
-        expiresAt: data.expiresAt,
-        expiresInMs: data.expiresInMs
+        mode: data.mode
       };
       state.session = {
         id: data.callId,
@@ -624,6 +617,9 @@ var InviteAcceptedHandler = class extends BaseSocketHandler {
       return;
     }
     this.updateStore((state) => {
+      if (state.session && data.status) {
+        state.session.status = data.status;
+      }
       const userId = data.participant.userId;
       if (state.outgoingInvites[userId]) {
         state.outgoingInvites[userId].status = "accepted";
@@ -995,6 +991,11 @@ var ParticipantAddedHandler = class extends BaseSocketHandler {
       this.logger.warn("Ignoring participant added for different call", { callId: data.callId });
       return;
     }
+    this.updateStore((state) => {
+      if (state.session && data.status) {
+        state.session.status = data.status;
+      }
+    });
     eventBus.emit("participant:updated" /* PARTICIPANT_UPDATED */, {
       participantId: data.participant.participantId,
       timestamp: Date.now()
@@ -1005,6 +1006,32 @@ var ParticipantAddedHandler = class extends BaseSocketHandler {
   }
 };
 
+// src/core/socketio/handlers/room-started.handler.ts
+var RoomStartedHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:roomStarted";
+    this.schema = callRoomStartedSchema;
+  }
+  handle(data) {
+    this.logger.info("LiveKit room started", {
+      callId: data.callId,
+      roomName: data.roomName
+    });
+    this.updateStore((state) => {
+      if (state.session) {
+        state.session.status = data.status;
+      }
+    });
+    eventBus.emit("call:started" /* CALL_STARTED */, {
+      callId: data.callId,
+      roomName: data.roomName,
+      timestamp: Date.now()
+    });
+    this.logger.debug("Session status updated to active");
+  }
+};
+
 // src/core/socketio/handlers/handler.registry.ts
 var logger = createLogger("socketio:registry");
 var SocketHandlerRegistry = class {
@@ -1029,7 +1056,9 @@ var SocketHandlerRegistry = class {
       new InviteMissedHandler(this.options),
       new SessionCancelledHandler(this.options),
       new SessionMissedHandler(this.options),
-      new ParticipantAddedHandler(this.options)
+      new ParticipantAddedHandler(this.options),
+      // Phase 4: LiveKit room events
+      new RoomStartedHandler(this.options)
     ];
     for (const handler of handlers) {
       this.handlers.set(handler.eventName, handler);
@@ -1964,6 +1993,9 @@ function createCallsService(config) {
   }
   async function accept(callId) {
     ensureApiConfigured();
+    rtcStore.setState((state) => {
+      state.incomingInvite = null;
+    });
     return CallsService.postSignalCallsByCallIdAccept({
       callId,
       appId
@@ -2275,50 +2307,10 @@ function useCallInitiated() {
 function useSessionDuration() {
   return 0;
 }
-var defaultRoomOptions = {
-  adaptiveStream: true,
-  dynacast: true
-};
-function useRoom(options) {
-  const [room] = React.useState(() => new livekitClient.Room(options || defaultRoomOptions));
-  const livekitInfo = useRtcStore((state) => state.session?.livekitInfo);
-  React.useEffect(() => {
-    if (!livekitInfo) {
-      return;
-    }
-    room.connect(livekitInfo.url, livekitInfo.token);
-    return () => {
-      room.disconnect();
-    };
-  }, [livekitInfo, room]);
-  if (!livekitInfo) {
-    return null;
-  }
-  return room;
-}
-function useParticipantMetadata(participantOrIdentity) {
-  const room = useRoom();
-  const participants = componentsReact.useParticipants(room ? { room } : {});
-  let resolvedParticipant;
-  if (typeof participantOrIdentity === "string") {
-    resolvedParticipant = participants.find(
-      (p) => p.identity === participantOrIdentity
-    );
-  } else if (participantOrIdentity) {
-    resolvedParticipant = participantOrIdentity;
-  }
-  const livekitInfo = componentsReact.useParticipantInfo(
-    resolvedParticipant ? { participant: resolvedParticipant } : {}
-  );
-  if (!livekitInfo.metadata) {
-    return null;
-  }
+function useParticipantMetadata(participant) {
+  const info = componentsReact.useParticipantInfo({ participant });
   try {
-    const metadata = JSON.parse(livekitInfo.metadata);
-    if (!metadata.userId || !metadata.role) {
-      console.warn("Invalid participant metadata: missing required fields", metadata);
-      return null;
-    }
+    const metadata = JSON.parse(info.metadata);
     return {
       userId: metadata.userId,
       role: metadata.role,
@@ -2334,6 +2326,47 @@ function useParticipantMetadata(participantOrIdentity) {
   }
 }
 
+// src/hooks/useLivekitInfo.ts
+function useLivekitInfo() {
+  return useRtcStore((state) => state.session?.livekitInfo ?? null);
+}
+
+// src/hooks/useHasActiveSession.ts
+function useHasActiveSession() {
+  return useRtcStore((state) => {
+    if (!state.session) {
+      return false;
+    }
+    return state.session.status === "pending" || state.session.status === "active";
+  });
+}
+
+// src/hooks/useRoomReady.ts
+function useRoomReady() {
+  const livekitInfo = useLivekitInfo();
+  const { status } = useCallState();
+  return livekitInfo !== null && (status === "ready" || status === "active");
+}
+var logger4 = createLogger("useAutoConnectRoom");
+function useAutoConnectRoom(options) {
+  const [room] = React.useState(() => new livekitClient.Room(options));
+  const isReady = useRoomReady();
+  const livekitInfo = useLivekitInfo();
+  React.useEffect(() => {
+    if (isReady && livekitInfo) {
+      room.connect(livekitInfo.url, livekitInfo.token).catch((error) => {
+        logger4.error("Failed to connect to LiveKit room", error);
+      });
+    } else if (room.state === livekitClient.ConnectionState.Connected) {
+      room.disconnect();
+    }
+    return () => {
+      room.disconnect();
+    };
+  }, [isReady, livekitInfo, room]);
+  return room;
+}
+
 exports.RtcProvider = RtcProvider;
 exports.SdkEventType = SdkEventType;
 exports.apiConfig = apiConfig;
@@ -2349,6 +2382,7 @@ exports.callInviteSentSchema = callInviteSentSchema;
 exports.callJoinInfoSchema = callJoinInfoSchema;
 exports.callMissedSchema = callMissedSchema;
 exports.callParticipantAddedSchema = callParticipantAddedSchema;
+exports.callRoomStartedSchema = callRoomStartedSchema;
 exports.clearErrors = clearErrors;
 exports.eventBus = eventBus;
 exports.pushApiError = pushApiError;
@@ -2360,15 +2394,18 @@ exports.pushMediaPermissionError = pushMediaPermissionError;
 exports.pushNetworkError = pushNetworkError;
 exports.pushSocketValidationError = pushSocketValidationError;
 exports.pushStaleEventError = pushStaleEventError;
+exports.useAutoConnectRoom = useAutoConnectRoom;
 exports.useCallActions = useCallActions;
 exports.useCallInitiated = useCallInitiated;
 exports.useCallState = useCallState;
 exports.useEvent = useEvent;
+exports.useHasActiveSession = useHasActiveSession;
 exports.useIncomingInvite = useIncomingInvite;
 exports.useInviteAccepted = useInviteAccepted;
+exports.useLivekitInfo = useLivekitInfo;
 exports.useOutgoingInvites = useOutgoingInvites;
 exports.useParticipantMetadata = useParticipantMetadata;
-exports.useRoom = useRoom;
+exports.useRoomReady = useRoomReady;
 exports.useSdk = useSdk;
 exports.useSessionDuration = useSessionDuration;
 exports.useSessionId = useSessionId;