@amityco/ts-sdk 7.11.1-1440698f.0 → 7.11.1-19ae17f9.0

package/dist/index.cjs.js

@@ -732,7 +732,6 @@ const PAYLOAD2MODEL = {
     rooms: 'room',
     events: 'event',
     discussionCommunities: 'discussionCommunity',
-    viewers: 'viewer',
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
@@ -1463,14 +1462,12 @@ const createEventEmitter = () => {
 const proxyMqttEvents = (mqttClient, emitter) => {
     MQTT_EVENTS.forEach(event => {
         mqttClient === null || mqttClient === void 0 ? void 0 : mqttClient.on(event, (...params) => {
-            console.log('global event received => ', event);
             emitter.emit(event, params.length === 1 ? params[0] : params);
         });
     });
     // @ts-ignore
     mqttClient.on('message', (topic, payload) => {
         const message = JSON.parse(payload.toString());
-        console.log('message event received => ', message.eventType, message.data);
         emitter.emit(message.eventType, message.data);
     });
 };
@@ -12372,7 +12369,7 @@ const createInvitations = async (bundle) => {
  * @category Invitation API
  * @async
  */
-const acceptInvitation$1 = async (invitationId) => {
+const acceptInvitation = async (invitationId) => {
     var _a;
     const client = getActiveClient();
     client.log('invitation/acceptInvitation', invitationId);
@@ -12458,7 +12455,7 @@ const invitationLinkedObject = (invitation) => {
             }
             return undefined;
         }, accept: async () => {
-            await acceptInvitation$1(invitation._id);
+            await acceptInvitation(invitation._id);
         }, reject: async () => {
             await rejectInvitation(invitation._id);
         } });
@@ -28068,7 +28065,9 @@ const getRecordedUrl = async (roomId) => {
 const removeParticipant = async (roomId, participantUserId) => {
     const client = getActiveClient();
     client.log('room/removeParticipant', { roomId, participantUserId });
-    await client.http.delete(`/api/v1/rooms/${roomId}/participants/${participantUserId}`);
+    await client.http.delete(`/api/v1/rooms/${roomId}/participants`, {
+        data: { participantUserId },
+    });
     fireEvent('local.room.participantRemoved', {
         rooms: [{ _id: roomId }],
         users: [{ _id: participantUserId }],
@@ -28224,64 +28223,6 @@ const onRoomCoHostInvited = (callback) => {
     return createEventSubscriber(client, 'room/onRoomCoHostInvited', 'room.didCohostInvite', filter);
 };
 
-const getRoomById = async (roomId) => {
-    const client = getActiveClient();
-    client.log('room/getRoomById', roomId);
-    // Check if room is in tombstone
-    isInTombstone('room', roomId);
-    let data;
-    try {
-        const response = await client.http.get(`/api/v1/rooms/${roomId}`);
-        data = response.data;
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('room', roomId);
-        }
-        throw error;
-    }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(data, { cachedAt });
-    }
-    return {
-        data: data.rooms[0],
-        cachedAt,
-    };
-};
-getRoomById.locally = (roomId) => {
-    const client = getActiveClient();
-    client.log('room/getRoomById.locally', roomId);
-    // Check if room is in tombstone
-    isInTombstone('room', roomId);
-    const cachedAt = client.cache && Date.now();
-    const roomCache = pullFromCache(['room', 'get', roomId]);
-    if (!roomCache)
-        return;
-    return {
-        data: roomCache.data,
-        cachedAt,
-    };
-};
-
-const getWatchingCount$1 = async (roomId) => {
-    const client = getActiveClient();
-    client.log('room/getWatchingCount', { roomId });
-    const { data } = await client.http.get(`/api/v1/presence/rooms/${roomId}/users/count`);
-    pushToCache(['get', 'watchingCount', roomId], data);
-    fireEvent('local.room.watchingCountUpdated', data);
-    return data;
-};
-
-const getWatchingUsers$1 = async (roomId) => {
-    const client = getActiveClient();
-    client.log('room/getWatchingUsers', { roomId });
-    const { data } = await client.http.get(`/api/v1/presence/rooms/${roomId}/users`);
-    pushToCache(['watchingUsers', 'collection', roomId], data.viewers.map(viewer => viewer.userId));
-    fireEvent('local.room.watchingUsersFetched', data.viewers);
-    return data.viewers;
-};
-
 /**
  * ```js
  * import { onRoomCoHostInviteAccepted } from '@amityco/ts-sdk'
@@ -28299,12 +28240,10 @@ const getWatchingUsers$1 = async (roomId) => {
  */
 const onRoomCoHostInviteAccepted = (callback) => {
     const client = getActiveClient();
-    const filter = async (payload) => {
-        var _a;
+    const filter = (payload) => {
         const data = prepareMyInvitationsPayload(payload);
-        await getRoomById((_a = data.invitations) === null || _a === void 0 ? void 0 : _a[0].targetId);
         ingestInCache(data);
-        callback(data.invitations[0]);
+        callback(data.invitations);
     };
     return createEventSubscriber(client, 'room/onRoomCoHostInviteAccepted', 'room.didCohostInviteAccept', filter);
 };
@@ -28524,7 +28463,7 @@ const onRoomParticipantRemoved = (callback) => {
         ingestInCache(payload);
         callback(payload.rooms[0]);
     };
-    return createEventSubscriber(client, 'room/onRoomParticipantRemoved', 'room.participantRemoved', filter);
+    return createEventSubscriber(client, 'room/onRoomParticipantRemoved', 'local.room.participantRemoved', filter);
 };
 
 /**
@@ -28551,28 +28490,44 @@ const onRoomLeft = (callback) => {
     return createEventSubscriber(client, 'room/onRoomLeft', 'local.room.left', filter);
 };
 
-/**
- * ```js
- * import { onRoomParticipantRemoved } from '@amityco/ts-sdk'
- * const dispose = onRoomParticipantRemoved(room => {
- *   // ...
- * })
- * ```
- *
- * Fired when a participant has been removed from a {@link Amity.Room} locally
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Room Events
- */
-const onRoomParticipantRemovedLocal = (callback) => {
+const getRoomById = async (roomId) => {
     const client = getActiveClient();
-    const filter = (payload) => {
-        ingestInCache(payload);
-        callback(payload.rooms[0]);
+    client.log('room/getRoomById', roomId);
+    // Check if room is in tombstone
+    isInTombstone('room', roomId);
+    let data;
+    try {
+        const response = await client.http.get(`/api/v1/rooms/${roomId}`);
+        data = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('room', roomId);
+        }
+        throw error;
+    }
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) {
+        ingestInCache(data, { cachedAt });
+    }
+    return {
+        data: data.rooms[0],
+        cachedAt,
+    };
+};
+getRoomById.locally = (roomId) => {
+    const client = getActiveClient();
+    client.log('room/getRoomById.locally', roomId);
+    // Check if room is in tombstone
+    isInTombstone('room', roomId);
+    const cachedAt = client.cache && Date.now();
+    const roomCache = pullFromCache(['room', 'get', roomId]);
+    if (!roomCache)
+        return;
+    return {
+        data: roomCache.data,
+        cachedAt,
     };
-    return createEventSubscriber(client, 'room/onRoomParticipantRemoved', 'local.room.participantRemoved', filter);
 };
 
 const getRoom = (roomId, callback) => {
@@ -28584,9 +28539,6 @@ const getRoom = (roomId, callback) => {
         onRoomRecordedAvailable,
         onRoomParticipantJoined,
         onRoomParticipantLeft,
-        onRoomParticipantRemoved,
-        onRoomParticipantRemovedLocal,
-        convertEventPayload(onRoomCoHostInviteAccepted, 'targetId', 'room'),
     ], {
         callbackDataSelector: (data) => {
             if (!data)
@@ -28806,381 +28758,6 @@ const getRooms = (params, callback, config) => {
 };
 /* end_public_function */
 
-/**
- * ```js
- * import { onRoomWaitingReconnect } from '@amityco/ts-sdk'
- * const dispose = onRoomWaitingReconnect(room => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.RoomWatchingCount} is waiting for reconnection
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Room Events
- */
-const onRoomWatchingCountUpdated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        callback(payload);
-    };
-    return createEventSubscriber(client, 'room/onRoomWatchingCountUpdated', 'local.room.watchingCountUpdated', filter);
-};
-
-/**
- * ```js
- * import RoomRepository from '@amityco/ts-sdk'
- * const unsubscribe = RoomRepository.getWatchingCount('roomId', ({count}) => {
- *   console.log('Current watching count:', count);
- * });
- * ```
- *
- * Observe the watching count for a room with real-time updates
- *
- * @param roomId The ID of the room to observe watching count for
- * @param callback The function to call when watching count changes
- * @returns An {@link Amity.Unsubscriber} function to stop observing
- *
- * @category Room Observable
- */
-const getWatchingCount = (roomId, callback) => {
-    const { _id: userId } = getCurrentUser();
-    if (!userId)
-        throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log('For using Live Object feature you need to enable Cache!');
-    }
-    const timestamp = Date.now();
-    log(`liveWatchingCount(tmpid: ${timestamp}) > listen`);
-    const disposers = [];
-    let model;
-    const dispatcher = (data) => {
-        callback(data !== null && data !== void 0 ? data : { count: 0, referenceTimestamp: undefined });
-    };
-    const realtimeRouter = (_) => {
-        var _a;
-        const data = (_a = pullFromCache(['get', 'watchingCount', roomId])) === null || _a === void 0 ? void 0 : _a.data;
-        if (isEqual(model, data))
-            return;
-        dispatcher(data);
-    };
-    const onFetch = () => {
-        var _a;
-        const data = (_a = pullFromCache(['get', 'watchingCount', roomId])) === null || _a === void 0 ? void 0 : _a.data;
-        dispatcher(data);
-    };
-    disposers.push(onRoomWatchingCountUpdated(realtimeRouter));
-    onFetch();
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
-/**
- * ```js
- * import { onRoomWatchingUsersFetched } from '@amityco/ts-sdk'
- * const dispose = onRoomWatchingUsersFetched(users => {
- *   console.log('Watching users fetched:', users);
- * })
- * ```
- *
- * Fired when {@link Amity.User[]} watching users data is fetched
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Room Events
- */
-const onRoomWatchingUsersFetched = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        callback(payload);
-    };
-    return createEventSubscriber(client, 'room/onRoomWatchingUsersFetched', 'local.room.watchingUsersFetched', filter);
-};
-
-/**
- * ```js
- * import RoomRepository from '@amityco/ts-sdk'
- * const unsubscribe = RoomRepository.getWatchingUsers('roomId', ({count}) => {
- *   console.log('Current watching count:', count);
- * });
- * ```
- *
- * Observe the watching count for a room with real-time updates
- *
- * @param roomId The ID of the room to observe watching count for
- * @param callback The function to call when watching count changes
- * @returns An {@link Amity.Unsubscriber} function to stop observing
- *
- * @category Room Observable
- */
-const getWatchingUsers = (roomId, callback) => {
-    const { _id: userId } = getCurrentUser();
-    if (!userId)
-        throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log('For using Live Object feature you need to enable Cache!');
-    }
-    const timestamp = Date.now();
-    log(`liveWatchingCount(tmpid: ${timestamp}) > listen`);
-    const disposers = [];
-    let model;
-    const dispatcher = (data) => {
-        var _a;
-        const callbackData = (_a = data === null || data === void 0 ? void 0 : data.map((userId) => { var _a; return (_a = pullFromCache(['user', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data; }).filter(isNonNullable).map(LinkedObject.user)) !== null && _a !== void 0 ? _a : [];
-        callback(callbackData);
-    };
-    const realtimeRouter = (_) => {
-        var _a;
-        const data = (_a = pullFromCache([
-            'watchingUsers',
-            'collection',
-            roomId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (isEqual(model, data))
-            return;
-        dispatcher(data);
-    };
-    const onFetch = () => {
-        var _a;
-        const data = (_a = pullFromCache([
-            'watchingUsers',
-            'collection',
-            roomId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        dispatcher(data);
-    };
-    disposers.push(onRoomWatchingUsersFetched(realtimeRouter));
-    onFetch();
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
-const getPresenceSetting = async () => {
-    const client = getActiveClient();
-    client.log('presence/getPresenceSetting');
-    const { data } = await client.http.get('/api/v1/presence/settings');
-    pushToCache(['get', 'presenceSetting'], data);
-    return data;
-};
-
-class WatchingSyncEngine {
-    constructor(roomId) {
-        this.roomId = roomId;
-        this.config = {
-            heartbeatInterval: 1 * MINUTE,
-            presenceSyncInterval: 30 * SECOND$1,
-        };
-        // Initialize config asynchronously - don't await in constructor
-        this.initializeConfig().catch(error => {
-            console.error('Failed to initialize WatchingSyncEngine config in constructor:', error);
-        });
-    }
-    async initializeConfig() {
-        try {
-            // Get presence settings from API with retry logic
-            const presenceSettings = await WatchingSyncEngine.getPresenceSettingWithRetry();
-            if (presenceSettings) {
-                // Set intervals from network settings (convert from minutes to milliseconds)
-                this.config = {
-                    heartbeatInterval: (presenceSettings.network.heartbeatInterval || 5) * 60 * 1000,
-                    presenceSyncInterval: (presenceSettings.network.presenceSyncInterval || 1) * 60 * 1000,
-                };
-            }
-            else {
-                // Use default intervals if all retries failed
-                this.config.heartbeatInterval = 5 * 60 * 1000; // 5 minutes
-                this.config.presenceSyncInterval = 1 * 60 * 1000; // 1 minute
-            }
-        }
-        catch (error) {
-            console.error('Failed to initialize WatchingSyncEngine config:', error);
-            // Use default intervals if settings fetch fails
-            this.config.heartbeatInterval = 5 * 60 * 1000; // 5 minutes
-            this.config.presenceSyncInterval = 1 * 60 * 1000; // 1 minute
-        }
-    }
-    static async getPresenceSettingWithRetry(maxRetries = 5) {
-        for (let attempt = 0; attempt < maxRetries; attempt += 1) {
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                const presenceSettings = await getPresenceSetting();
-                return presenceSettings;
-            }
-            catch (error) {
-                if (attempt >= maxRetries - 1) {
-                    console.error(`Failed to get presence setting after ${maxRetries} attempts:`, error);
-                    return null;
-                }
-                // Calculate delay: 20 seconds + random jitter (0-5 seconds)
-                const jitter = Math.random() * 5000; // 0-5 seconds in milliseconds
-                const delay = 20000 + jitter; // 20 seconds + jitter
-                console.warn(`Failed to get presence setting (attempt ${attempt + 1}/${maxRetries}), retrying in ${Math.round(delay / 1000)}s:`, error);
-                // Wait before retry
-                // eslint-disable-next-line no-await-in-loop
-                await new Promise(resolve => {
-                    setTimeout(resolve, delay);
-                });
-            }
-        }
-        return null;
-    }
-    startWatching() {
-        if (!this.roomId) {
-            console.error('WatchingSyncEngine: roomId is required');
-            return;
-        }
-        // Stop existing timer if any
-        this.stopWatching();
-        // Send immediate heartbeat when starting
-        this.sendHeartbeat();
-        // Start heartbeat timer
-        this.heartbeatTimer = setInterval(() => {
-            this.sendHeartbeat();
-        }, this.config.heartbeatInterval);
-    }
-    async sendHeartbeat() {
-        if (!this.roomId)
-            return;
-        try {
-            const client = getActiveClient();
-            await client.http.post(`/api/v1/presence/rooms/${this.roomId}/heartbeat`);
-        }
-        catch (error) {
-            console.error('Heartbeat failed:', error);
-        }
-    }
-    stopWatching() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = undefined;
-        }
-    }
-    syncWatchingUsers() {
-        if (!this.roomId) {
-            console.error('WatchingSyncEngine: roomId is required');
-            return;
-        }
-        // Stop existing timer if any
-        this.stopSyncWatchingUsers();
-        // Fetch watching data immediately when starting
-        this.fetchWatchingData();
-        // Start watching users sync timer
-        this.watchingUsersTimer = setInterval(() => {
-            this.fetchWatchingData();
-        }, this.config.presenceSyncInterval);
-    }
-    async fetchWatchingData() {
-        if (!this.roomId)
-            return;
-        try {
-            // Call both APIs to sync watching data
-            const [count, users] = await Promise.all([
-                getWatchingCount$1(this.roomId),
-                getWatchingUsers$1(this.roomId),
-            ]);
-            // Data is automatically cached by the individual API calls
-            const client = getActiveClient();
-            client.log('room/watchingSync', { roomId: this.roomId, count, usersCount: users.length });
-        }
-        catch (error) {
-            console.error('Watching users sync failed:', error);
-        }
-    }
-    stopSyncWatchingUsers() {
-        if (this.watchingUsersTimer) {
-            clearInterval(this.watchingUsersTimer);
-            this.watchingUsersTimer = undefined;
-        }
-    }
-    /**
-     * Cleanup method to stop all timers and release resources
-     * Call this when the engine instance is no longer needed
-     */
-    destroy() {
-        // Stop all active timers
-        this.stopWatching();
-        this.stopSyncWatchingUsers();
-    }
-    // Session Management
-    onSessionDestroyed() {
-        // Stop all timers when session is destroyed and cleanup
-        this.destroy();
-    }
-    onTokenExpired() {
-        // Stop timers when token expires
-        this.stopWatching();
-        this.stopSyncWatchingUsers();
-    }
-}
-
-// Global map to store instances
-const engineInstances = new Map();
-/**
- * Get or create a WatchingSyncEngine instance for a room
- *
- * @param roomId The room ID to get/create engine for
- * @returns WatchingSyncEngine instance for the room
- */
-const getWatchingSyncEngine = (roomId) => {
-    let engine = engineInstances.get(roomId);
-    if (!engine) {
-        engine = new WatchingSyncEngine(roomId);
-        engineInstances.set(roomId, engine);
-    }
-    return engine;
-};
-/**
- * Destroy and remove engine instance for a room
- *
- * @param roomId The room ID to destroy engine for
- */
-const destroyWatchingSyncEngine = (roomId) => {
-    const engine = engineInstances.get(roomId);
-    if (engine) {
-        engine.destroy();
-        engineInstances.delete(roomId);
-    }
-};
-/**
- * Get all active room IDs with engines
- */
-const getActiveWatchingRooms = () => {
-    return Array.from(engineInstances.keys());
-};
-/**
- * Check if a room has an active engine
- */
-const hasWatchingSyncEngine = (roomId) => {
-    return engineInstances.has(roomId);
-};
-/**
- * Destroy all engines
- */
-const destroyAllWatchingSyncEngines = () => {
-    engineInstances.forEach(engine => {
-        engine.destroy();
-    });
-    engineInstances.clear();
-};
-/**
- * Session management functions
- */
-const onWatchingSyncSessionDestroyed = () => {
-    destroyAllWatchingSyncEngines();
-};
-const onWatchingSyncTokenExpired = () => {
-    engineInstances.forEach(engine => {
-        engine.onTokenExpired();
-    });
-};
-
 var index$8 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createRoom: createRoom,
@@ -29208,16 +28785,7 @@ var index$8 = /*#__PURE__*/Object.freeze({
     onRoomParticipantRemoved: onRoomParticipantRemoved,
     onRoomLeft: onRoomLeft,
     getRoom: getRoom,
-    getRooms: getRooms,
-    getWatchingCount: getWatchingCount,
-    getWatchingUsers: getWatchingUsers,
-    getWatchingSyncEngine: getWatchingSyncEngine,
-    destroyWatchingSyncEngine: destroyWatchingSyncEngine,
-    getActiveWatchingRooms: getActiveWatchingRooms,
-    hasWatchingSyncEngine: hasWatchingSyncEngine,
-    destroyAllWatchingSyncEngines: destroyAllWatchingSyncEngines,
-    onWatchingSyncSessionDestroyed: onWatchingSyncSessionDestroyed,
-    onWatchingSyncTokenExpired: onWatchingSyncTokenExpired
+    getRooms: getRooms
 });
 
 /* begin_public_function
@@ -31547,28 +31115,6 @@ const cancelInvitation = async (invitationId) => {
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: invitation.accept
-*/
-/**
- * ```js
- * import { acceptInvitation } from '@amityco/ts-sdk'
- * const isAccepted = await acceptInvitation(invitationId)
- * ```
- *
- * Accepts a {@link Amity.Invitation} object
- *
- * @param invitationId the {@link Amity.Invitation} to accept
- * @returns A success boolean if the {@link Amity.Invitation} was accepted
- *
- * @category Invitation API
- * @async
- */
-const acceptInvitation = async (invitationId) => {
-    return acceptInvitation$1(invitationId);
-};
-/* end_public_function */
-
 class MyInvitationsPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
         const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
@@ -31807,7 +31353,7 @@ const getInvitations = (params, callback) => {
         callback(data.map(LinkedObject.invitation));
     };
     const realtimeRouter = (data) => {
-        const invitations = (Array.isArray(data) ? data : [data]).filter(({ targetId, targetType }) => targetId === params.targetId && targetType === params.targetType);
+        const invitations = data.filter(({ targetId, targetType }) => targetId === params.targetId && targetType === params.targetType);
         dispatcher(invitations);
     };
     // Only subscribe to room co-host events for now (since that's what we have implemented)
@@ -31827,7 +31373,6 @@ const getInvitations = (params, callback) => {
 var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     cancelInvitation: cancelInvitation,
-    acceptInvitation: acceptInvitation,
     onLocalInvitationCreated: onLocalInvitationCreated,
     onLocalInvitationUpdated: onLocalInvitationUpdated,
     onLocalInvitationCanceled: onLocalInvitationCanceled,