@amityco/ts-sdk 7.7.1-99f7166.0 → 7.7.1-b56aa2f.0

package/dist/index.esm.js

@@ -1367,7 +1367,8 @@ const MQTT_EVENTS = [
     'video-streaming.didStop',
     'video-streaming.didFlag',
     'video-streaming.didTerminate',
-    // 'user.didGlobalBan' remove due to message event,
+    'video-streaming.viewerDidBan',
+    'video-streaming.viewerDidUnban',
     'liveReaction.created',
 ];
 /** @hidden */
@@ -22161,6 +22162,577 @@ const channelMemberLinkedObject = (channelMember) => {
         } });
 };
 
+/**
+ *
+ * get current user's membership data
+ *
+ * @returns the {@link Amity.Membership<'channel'>} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const getMyMembership$1 = (channelId) => {
+    const client = getActiveClient();
+    client.log('channel/getMyMembership.locally');
+    const cacheChannelUser = pullFromCache([
+        'channelUsers',
+        'get',
+        `${channelId}#${client.userId}`,
+    ]);
+    if (!cacheChannelUser) {
+        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    return {
+        data: cacheChannelUser.data,
+        cachedAt: cacheChannelUser.cachedAt,
+    };
+};
+
+/**
+ * ```js
+ * import { isEqual } from '~/utils/isEqual'
+ * const isEqual = isEqual(post1, post2)
+ * ```
+ *
+ * Compares two Amity.Model
+ *
+ * @param x the Amity.Model to compare
+ * @param y the Amity.Model to compare wit x
+ * @returns a boolean based on equality
+ *
+ * @category utility
+ * @private
+ */
+function isEqual(x, y) {
+    if (x === null || x === undefined || y === null || y === undefined) {
+        return x === y;
+    }
+    // after this just checking type of one would be enough
+    if (x.constructor !== y.constructor) {
+        return false;
+    }
+    // if they are functions, they should exactly refer to same one (because of closures)
+    if (x instanceof Function) {
+        return x === y;
+    }
+    // if they are regexps, they should exactly refer to same one
+    if (x instanceof RegExp) {
+        return x === y;
+    }
+    if (x === y || x.valueOf() === y.valueOf()) {
+        return true;
+    }
+    if (Array.isArray(x) && x.length !== y.length) {
+        return false;
+    }
+    // check each element of the array for equality
+    if (Array.isArray(x) && Array.isArray(y)) {
+        if (x.length !== y.length)
+            return false;
+        for (let i = 0; i < x.length; i += 1) {
+            if (!isEqual(x[i], y[i]))
+                return false;
+        }
+        // if all elements are equal, the arrays are equal
+        return true;
+    }
+    // if they are dates, they must had equal valueOf
+    if (x instanceof Date) {
+        return false;
+    }
+    // if they are strictly equal, they both need to be object at least
+    if (!(x instanceof Object)) {
+        return false;
+    }
+    if (!(y instanceof Object)) {
+        return false;
+    }
+    // recursive object equality check
+    const p = Object.keys(x);
+    return (Object.keys(y).every(i => {
+        // @ts-ignore
+        return p.indexOf(i) !== -1;
+    }) &&
+        p.every(i => {
+            return isEqual(x[i], y[i]);
+        }));
+}
+
+const callbacks$c = [];
+let mainDisposer$b = null;
+const dispose$c = (cb) => {
+    const index = callbacks$c.indexOf(cb);
+    if (index > -1) {
+        callbacks$c.splice(index, 1);
+    }
+    if (callbacks$c.length === 0) {
+        mainDisposer$b === null || mainDisposer$b === void 0 ? void 0 : mainDisposer$b();
+    }
+};
+const onChannelCreated = (callback) => {
+    if (callbacks$c.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const data = await prepareChannelPayload(payload);
+            ingestInCache(data);
+            callbacks$c.forEach(cb => cb(data.channels[0]));
+        };
+        mainDisposer$b = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
+    }
+    callbacks$c.push(callback);
+    return () => dispose$c(callback);
+};
+
+const callbacks$b = [];
+const mainDisposers = [];
+const dispose$b = (cb) => {
+    const index = callbacks$b.indexOf(cb);
+    if (index > -1) {
+        callbacks$b.splice(index, 1);
+    }
+    if (callbacks$b.length === 0) {
+        mainDisposers.forEach(fn => fn());
+    }
+};
+const onChannelUpdated = (callback) => {
+    const client = getActiveClient();
+    if (callbacks$b.length === 0) {
+        const filter = async (payload) => {
+            const data = await prepareChannelPayload(payload);
+            ingestInCache(data);
+            callbacks$b.forEach(cb => cb(data.channels[0]));
+        };
+        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter));
+        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$b.forEach(cb => cb(payload.channels[0]))));
+    }
+    callbacks$b.push(callback);
+    return () => dispose$b(callback);
+};
+
+const addFlagIsDeletedSubChannelUnreadByChannelId = (channelId) => {
+    const cacheKey = ['subChannelUnreadInfo', 'get'];
+    const cachedSubChannelUnread = queryCache(cacheKey);
+    if (cachedSubChannelUnread) {
+        const cachedTargetSubChannelUnread = cachedSubChannelUnread === null || cachedSubChannelUnread === void 0 ? void 0 : cachedSubChannelUnread.filter(({ data }) => data.channelId === channelId);
+        cachedTargetSubChannelUnread.forEach(({ key, data }) => {
+            pushToCache(key, Object.assign(Object.assign({}, data), { isDeleted: true }));
+        });
+    }
+};
+
+const deleteChannelUnreadByChannelId = (channelId) => {
+    var _a;
+    const channelUnreadInfoCacheKey = ['channelUnreadInfo', 'get', channelId];
+    const channelUnreadInfoCache = (_a = pullFromCache(channelUnreadInfoCacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+    if (channelUnreadInfoCache) {
+        dropFromCache(channelUnreadInfoCacheKey);
+    }
+};
+
+const callbacks$a = [];
+let mainDisposer$a = null;
+const dispose$a = (cb) => {
+    const index = callbacks$a.indexOf(cb);
+    if (index > -1) {
+        callbacks$a.splice(index, 1);
+    }
+    if (callbacks$a.length === 0) {
+        mainDisposer$a === null || mainDisposer$a === void 0 ? void 0 : mainDisposer$a();
+    }
+};
+const onChannelDeleted = (callback) => {
+    if (callbacks$a.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const data = await prepareChannelPayload(payload);
+            const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+            const isLegacyUnreadCount = client.useLegacyUnreadCount;
+            data.channels.forEach(channel => {
+                if (isConsistentMode) {
+                    addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+                    deleteChannelUnreadByChannelId(channel.channelId);
+                }
+                else if (isLegacyUnreadCount) {
+                    const cacheKey = ['channelUnread', 'get', channel.channelId];
+                    const cache = pullFromCache(cacheKey);
+                    if (cache) {
+                        pushToCache(cacheKey, Object.assign(Object.assign({}, cache), { isDeleted: true }));
+                    }
+                }
+            });
+            ingestInCache(data);
+            callbacks$a.forEach(cb => cb(data.channels[0]));
+        };
+        mainDisposer$a = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
+    }
+    callbacks$a.push(callback);
+    return () => dispose$a(callback);
+};
+
+const callbacks$9 = [];
+let mainDisposer$9 = null;
+const dispose$9 = (cb) => {
+    const index = callbacks$9.indexOf(cb);
+    if (index > -1) {
+        callbacks$9.splice(index, 1);
+    }
+    if (callbacks$9.length === 0) {
+        mainDisposer$9 === null || mainDisposer$9 === void 0 ? void 0 : mainDisposer$9();
+    }
+};
+const onChannelJoined = (callback) => {
+    if (callbacks$9.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const preparedPayload = await prepareChannelPayload(payload);
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$9.forEach(cb => cb(channels[0], channelUsers[0]));
+        };
+        mainDisposer$9 = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
+    }
+    callbacks$9.push(callback);
+    return () => dispose$9(callback);
+};
+
+const callbacks$8 = [];
+let mainDisposer$8 = null;
+const dispose$8 = (cb) => {
+    const index = callbacks$8.indexOf(cb);
+    if (index > -1) {
+        callbacks$8.splice(index, 1);
+    }
+    if (callbacks$8.length === 0) {
+        mainDisposer$8 === null || mainDisposer$8 === void 0 ? void 0 : mainDisposer$8();
+    }
+};
+const onChannelLeft = (callback) => {
+    if (callbacks$8.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const { userId } = getActiveClient();
+            const { channelUsers: leftUsers } = payload;
+            const isLeftByMe = leftUsers.some(user => user.userId === userId);
+            const preparedPayload = await prepareChannelPayload(payload, {
+                isMessagePreviewUpdated: isLeftByMe,
+            });
+            const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+            const isLegacyUnreadCount = client.useLegacyUnreadCount;
+            if (isLeftByMe) {
+                preparedPayload.channels.forEach(channel => {
+                    if (isConsistentMode) {
+                        addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+                        deleteChannelUnreadByChannelId(channel.channelId);
+                    }
+                    else if (isLegacyUnreadCount) {
+                        dropFromCache(['channelUnread', 'get', channel.channelId]);
+                    }
+                });
+            }
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$8.forEach(cb => cb(channels[0], channelUsers[0]));
+        };
+        mainDisposer$8 = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+    }
+    callbacks$8.push(callback);
+    return () => dispose$8(callback);
+};
+
+const callbacks$7 = [];
+let mainDisposer$7 = null;
+const dispose$7 = (cb) => {
+    const index = callbacks$7.indexOf(cb);
+    if (index > -1) {
+        callbacks$7.splice(index, 1);
+    }
+    if (callbacks$7.length === 0) {
+        mainDisposer$7 === null || mainDisposer$7 === void 0 ? void 0 : mainDisposer$7();
+    }
+};
+const onChannelSetMuted = (callback) => {
+    if (callbacks$7.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payloads) => {
+            var _a;
+            payloads.forEach(payload => {
+                upsertInCache(['channel', 'get', payload.channelId], {
+                    // If muteTimeout > now => user is muted
+                    // Otherwise => user is unmuted
+                    isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+                });
+            });
+            const channel = (_a = pullFromCache([
+                'channel',
+                'get',
+                payloads[0].channelId,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            if (channel) {
+                callbacks$7.forEach(cb => cb(channel));
+            }
+        };
+        mainDisposer$7 = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
+    }
+    callbacks$7.push(callback);
+    return () => dispose$7(callback);
+};
+
+const callbacks$6 = [];
+let mainDisposer$6 = null;
+const dispose$6 = (cb) => {
+    const index = callbacks$6.indexOf(cb);
+    if (index > -1) {
+        callbacks$6.splice(index, 1);
+    }
+    if (callbacks$6.length === 0) {
+        mainDisposer$6 === null || mainDisposer$6 === void 0 ? void 0 : mainDisposer$6();
+    }
+};
+const onChannelMemberAdded = (callback) => {
+    if (callbacks$6.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const preparedPayload = await prepareChannelPayload(payload);
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$6.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'member')));
+        };
+        mainDisposer$6 = createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
+    }
+    callbacks$6.push(callback);
+    return () => dispose$6(callback);
+};
+
+const callbacks$5 = [];
+let mainDisposer$5 = null;
+const dispose$5 = (cb) => {
+    const index = callbacks$5.indexOf(cb);
+    if (index > -1) {
+        callbacks$5.splice(index, 1);
+    }
+    if (callbacks$5.length === 0) {
+        mainDisposer$5 === null || mainDisposer$5 === void 0 ? void 0 : mainDisposer$5();
+    }
+};
+const onChannelMemberRemoved = (callback) => {
+    if (callbacks$5.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const preparedPayload = await prepareChannelPayload(payload);
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$5.forEach(cb => cb(channels[0], channelUsers[0]));
+        };
+        mainDisposer$5 = createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
+    }
+    callbacks$5.push(callback);
+    return () => dispose$5(callback);
+};
+
+const callbacks$4 = [];
+let mainDisposer$4 = null;
+const dispose$4 = (cb) => {
+    const index = callbacks$4.indexOf(cb);
+    if (index > -1) {
+        callbacks$4.splice(index, 1);
+    }
+    if (callbacks$4.length === 0) {
+        mainDisposer$4 === null || mainDisposer$4 === void 0 ? void 0 : mainDisposer$4();
+    }
+};
+const onChannelMemberBanned = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        const preparedPayload = await prepareChannelPayload(payload);
+        const { channels, channelUsers } = preparedPayload;
+        const isCurrentUserBanned = channelUsers.some(cu => cu.membership === 'banned' && cu.userId === client.userId);
+        if (client.isUnreadCountEnabled &&
+            client.getMarkerSyncConsistentMode() &&
+            isCurrentUserBanned) {
+            preparedPayload.channels.forEach(channel => {
+                addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+                deleteChannelUnreadByChannelId(channel.channelId);
+            });
+        }
+        ingestInCache(preparedPayload);
+        callbacks$4.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'banned')));
+    };
+    mainDisposer$4 = createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+    callbacks$4.push(callback);
+    return () => dispose$4(callback);
+};
+
+const callbacks$3 = [];
+let mainDisposer$3 = null;
+const dispose$3 = (cb) => {
+    const index = callbacks$3.indexOf(cb);
+    if (index > -1) {
+        callbacks$3.splice(index, 1);
+    }
+    if (callbacks$3.length === 0) {
+        mainDisposer$3 === null || mainDisposer$3 === void 0 ? void 0 : mainDisposer$3();
+    }
+};
+const onChannelMemberUnbanned = (callback) => {
+    if (callbacks$3.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const preparedPayload = await prepareChannelPayload(payload);
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$3.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'none')));
+        };
+        mainDisposer$3 = createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
+    }
+    callbacks$3.push(callback);
+    return () => dispose$3(callback);
+};
+
+const callbacks$2 = [];
+let mainDisposer$2 = null;
+const dispose$2 = (cb) => {
+    const index = callbacks$2.indexOf(cb);
+    if (index > -1) {
+        callbacks$2.splice(index, 1);
+    }
+    if (callbacks$2.length === 0) {
+        mainDisposer$2 === null || mainDisposer$2 === void 0 ? void 0 : mainDisposer$2();
+    }
+};
+const onChannelMemberRoleAdded = (callback) => {
+    if (callbacks$2.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const { channels, channelUsers } = payload;
+            callbacks$2.forEach(cb => cb(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')));
+        };
+        mainDisposer$2 = createEventSubscriber(client, 'onChannelMemberRoleAdded', 'local.channel-moderator.role-added', filter);
+    }
+    callbacks$2.push(callback);
+    return () => dispose$2(callback);
+};
+
+const callbacks$1 = [];
+let mainDisposer$1 = null;
+const dispose$1 = (cb) => {
+    const index = callbacks$1.indexOf(cb);
+    if (index > -1) {
+        callbacks$1.splice(index, 1);
+    }
+    if (callbacks$1.length === 0) {
+        mainDisposer$1 === null || mainDisposer$1 === void 0 ? void 0 : mainDisposer$1();
+    }
+};
+const onChannelMemberRoleRemoved = (callback) => {
+    if (callbacks$1.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const { channels, channelUsers } = payload;
+            callback(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member'));
+        };
+        mainDisposer$1 = createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'local.channel-moderator.role-removed', filter);
+    }
+    callbacks$1.push(callback);
+    return () => dispose$1(callback);
+};
+
+const callbacks = [];
+let mainDisposer = null;
+const dispose = (cb) => {
+    const index = callbacks.indexOf(cb);
+    if (index > -1) {
+        callbacks.splice(index, 1);
+    }
+    if (callbacks.length === 0) {
+        mainDisposer === null || mainDisposer === void 0 ? void 0 : mainDisposer();
+    }
+};
+const onChannelSetUserMuted = (callback) => {
+    if (callbacks.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            var _a, _b;
+            payload.userIds.forEach(userId => 
+            // If muteTimeout > now => user is muted
+            // Otherwise => user is unmuted
+            upsertInCache(['channelUsers', 'get', `${payload.channelId}#${userId}`], {
+                isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+            }));
+            const channel = (_a = pullFromCache([
+                'channel',
+                'get',
+                payload.channelId,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            const channelUser = (_b = pullFromCache([
+                'channelUsers',
+                'get',
+                `${payload.channelId}#${payload.userIds[0]}`,
+            ])) === null || _b === void 0 ? void 0 : _b.data;
+            if (channel && channelUser) {
+                callbacks.forEach(cb => cb(channel, channelUser));
+            }
+        };
+        mainDisposer = createEventSubscriber(client, 'onChannelUserMute', 'channel.setMutedUsers', filter);
+    }
+    callbacks.push(callback);
+    return () => dispose(callback);
+};
+
+const getMyMembership = (channelId, callback) => {
+    const { _id: userId } = getActiveUser();
+    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('This observable object need the cache data!');
+    }
+    const timestamp = Date.now();
+    log(`liveMymembership(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    let isUnsyncedModel = false; // for messages
+    let model;
+    const dispatcher = (data) => {
+        callback(Object.assign(Object.assign({}, data), { data: data.data ? channelMemberLinkedObject(data.data) : data.data }));
+    };
+    const realtimeRouter = (_, __) => {
+        const { data } = getMyMembership$1(channelId);
+        if (isEqual(model, data))
+            return;
+        dispatcher({
+            loading: false,
+            data,
+        });
+    };
+    const onFetch = () => {
+        const query = createQuery(async () => getMyMembership$1(channelId));
+        runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
+                });
+                isUnsyncedModel = true;
+                disposers.forEach(fn => fn());
+            }
+            else if (!isUnsyncedModel) {
+                dispatcher({ loading, data, origin, error });
+            }
+            if (error) {
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(onChannelMemberBanned(realtimeRouter));
+    disposers.push(onChannelMemberUnbanned(realtimeRouter));
+    disposers.push(onChannelSetUserMuted(realtimeRouter));
+    onFetch();
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
 const channelLinkedObject = (channel) => {
     var _a;
     let previewMembers = [];
@@ -22178,6 +22750,7 @@ const channelLinkedObject = (channel) => {
     return shallowClone(channel, {
         markAsRead: () => markAsRead(channel.channelInternalId),
         previewMembers,
+        myMembership: (callback) => getMyMembership(channel.channelId, callback),
     });
 };
 
@@ -22804,99 +23377,6 @@ const setClientToken = async (params) => {
     return { accessToken, users };
 };
 
-const addFlagIsDeletedSubChannelUnreadByChannelId = (channelId) => {
-    const cacheKey = ['subChannelUnreadInfo', 'get'];
-    const cachedSubChannelUnread = queryCache(cacheKey);
-    if (cachedSubChannelUnread) {
-        const cachedTargetSubChannelUnread = cachedSubChannelUnread === null || cachedSubChannelUnread === void 0 ? void 0 : cachedSubChannelUnread.filter(({ data }) => data.channelId === channelId);
-        cachedTargetSubChannelUnread.forEach(({ key, data }) => {
-            pushToCache(key, Object.assign(Object.assign({}, data), { isDeleted: true }));
-        });
-    }
-};
-
-const deleteChannelUnreadByChannelId = (channelId) => {
-    var _a;
-    const channelUnreadInfoCacheKey = ['channelUnreadInfo', 'get', channelId];
-    const channelUnreadInfoCache = (_a = pullFromCache(channelUnreadInfoCacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-    if (channelUnreadInfoCache) {
-        dropFromCache(channelUnreadInfoCacheKey);
-    }
-};
-
-const callbacks$c = [];
-let mainDisposer$b = null;
-const dispose$c = (cb) => {
-    const index = callbacks$c.indexOf(cb);
-    if (index > -1) {
-        callbacks$c.splice(index, 1);
-    }
-    if (callbacks$c.length === 0) {
-        mainDisposer$b === null || mainDisposer$b === void 0 ? void 0 : mainDisposer$b();
-    }
-};
-const onChannelDeleted = (callback) => {
-    if (callbacks$c.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const data = await prepareChannelPayload(payload);
-            const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
-            const isLegacyUnreadCount = client.useLegacyUnreadCount;
-            data.channels.forEach(channel => {
-                if (isConsistentMode) {
-                    addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-                    deleteChannelUnreadByChannelId(channel.channelId);
-                }
-                else if (isLegacyUnreadCount) {
-                    const cacheKey = ['channelUnread', 'get', channel.channelId];
-                    const cache = pullFromCache(cacheKey);
-                    if (cache) {
-                        pushToCache(cacheKey, Object.assign(Object.assign({}, cache), { isDeleted: true }));
-                    }
-                }
-            });
-            ingestInCache(data);
-            callbacks$c.forEach(cb => cb(data.channels[0]));
-        };
-        mainDisposer$b = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
-    }
-    callbacks$c.push(callback);
-    return () => dispose$c(callback);
-};
-
-const callbacks$b = [];
-let mainDisposer$a = null;
-const dispose$b = (cb) => {
-    const index = callbacks$b.indexOf(cb);
-    if (index > -1) {
-        callbacks$b.splice(index, 1);
-    }
-    if (callbacks$b.length === 0) {
-        mainDisposer$a === null || mainDisposer$a === void 0 ? void 0 : mainDisposer$a();
-    }
-};
-const onChannelMemberBanned = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const preparedPayload = await prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        const isCurrentUserBanned = channelUsers.some(cu => cu.membership === 'banned' && cu.userId === client.userId);
-        if (client.isUnreadCountEnabled &&
-            client.getMarkerSyncConsistentMode() &&
-            isCurrentUserBanned) {
-            preparedPayload.channels.forEach(channel => {
-                addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-                deleteChannelUnreadByChannelId(channel.channelId);
-            });
-        }
-        ingestInCache(preparedPayload);
-        callbacks$b.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'banned')));
-    };
-    mainDisposer$a = createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
-    callbacks$b.push(callback);
-    return () => dispose$b(callback);
-};
-
 function prepareUserPayload(response) {
     return {
         users: response.users.map(convertRawUserToInternalUser),
@@ -24621,291 +25101,6 @@ const accessTokenExpiryWatcher = (sessionHandler) => {
     return () => clearInterval(interval);
 };
 
-const callbacks$a = [];
-let mainDisposer$9 = null;
-const dispose$a = (cb) => {
-    const index = callbacks$a.indexOf(cb);
-    if (index > -1) {
-        callbacks$a.splice(index, 1);
-    }
-    if (callbacks$a.length === 0) {
-        mainDisposer$9 === null || mainDisposer$9 === void 0 ? void 0 : mainDisposer$9();
-    }
-};
-const onChannelCreated = (callback) => {
-    if (callbacks$a.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const data = await prepareChannelPayload(payload);
-            ingestInCache(data);
-            callbacks$a.forEach(cb => cb(data.channels[0]));
-        };
-        mainDisposer$9 = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
-    }
-    callbacks$a.push(callback);
-    return () => dispose$a(callback);
-};
-
-const callbacks$9 = [];
-const mainDisposers = [];
-const dispose$9 = (cb) => {
-    const index = callbacks$9.indexOf(cb);
-    if (index > -1) {
-        callbacks$9.splice(index, 1);
-    }
-    if (callbacks$9.length === 0) {
-        mainDisposers.forEach(fn => fn());
-    }
-};
-const onChannelUpdated = (callback) => {
-    const client = getActiveClient();
-    if (callbacks$9.length === 0) {
-        const filter = async (payload) => {
-            const data = await prepareChannelPayload(payload);
-            ingestInCache(data);
-            callbacks$9.forEach(cb => cb(data.channels[0]));
-        };
-        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter));
-        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$9.forEach(cb => cb(payload.channels[0]))));
-    }
-    callbacks$9.push(callback);
-    return () => dispose$9(callback);
-};
-
-const callbacks$8 = [];
-let mainDisposer$8 = null;
-const dispose$8 = (cb) => {
-    const index = callbacks$8.indexOf(cb);
-    if (index > -1) {
-        callbacks$8.splice(index, 1);
-    }
-    if (callbacks$8.length === 0) {
-        mainDisposer$8 === null || mainDisposer$8 === void 0 ? void 0 : mainDisposer$8();
-    }
-};
-const onChannelJoined = (callback) => {
-    if (callbacks$8.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const preparedPayload = await prepareChannelPayload(payload);
-            const { channels, channelUsers } = preparedPayload;
-            ingestInCache(preparedPayload);
-            callbacks$8.forEach(cb => cb(channels[0], channelUsers[0]));
-        };
-        mainDisposer$8 = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
-    }
-    callbacks$8.push(callback);
-    return () => dispose$8(callback);
-};
-
-const callbacks$7 = [];
-let mainDisposer$7 = null;
-const dispose$7 = (cb) => {
-    const index = callbacks$7.indexOf(cb);
-    if (index > -1) {
-        callbacks$7.splice(index, 1);
-    }
-    if (callbacks$7.length === 0) {
-        mainDisposer$7 === null || mainDisposer$7 === void 0 ? void 0 : mainDisposer$7();
-    }
-};
-const onChannelLeft = (callback) => {
-    if (callbacks$7.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const { userId } = getActiveClient();
-            const { channelUsers: leftUsers } = payload;
-            const isLeftByMe = leftUsers.some(user => user.userId === userId);
-            const preparedPayload = await prepareChannelPayload(payload, {
-                isMessagePreviewUpdated: isLeftByMe,
-            });
-            const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
-            const isLegacyUnreadCount = client.useLegacyUnreadCount;
-            if (isLeftByMe) {
-                preparedPayload.channels.forEach(channel => {
-                    if (isConsistentMode) {
-                        addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-                        deleteChannelUnreadByChannelId(channel.channelId);
-                    }
-                    else if (isLegacyUnreadCount) {
-                        dropFromCache(['channelUnread', 'get', channel.channelId]);
-                    }
-                });
-            }
-            const { channels, channelUsers } = preparedPayload;
-            ingestInCache(preparedPayload);
-            callbacks$7.forEach(cb => cb(channels[0], channelUsers[0]));
-        };
-        mainDisposer$7 = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
-    }
-    callbacks$7.push(callback);
-    return () => dispose$7(callback);
-};
-
-const callbacks$6 = [];
-let mainDisposer$6 = null;
-const dispose$6 = (cb) => {
-    const index = callbacks$6.indexOf(cb);
-    if (index > -1) {
-        callbacks$6.splice(index, 1);
-    }
-    if (callbacks$6.length === 0) {
-        mainDisposer$6 === null || mainDisposer$6 === void 0 ? void 0 : mainDisposer$6();
-    }
-};
-const onChannelSetMuted = (callback) => {
-    if (callbacks$6.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payloads) => {
-            var _a;
-            payloads.forEach(payload => {
-                upsertInCache(['channel', 'get', payload.channelId], {
-                    // If muteTimeout > now => user is muted
-                    // Otherwise => user is unmuted
-                    isMuted: Date.parse(payload.muteTimeout) > Date.now(),
-                });
-            });
-            const channel = (_a = pullFromCache([
-                'channel',
-                'get',
-                payloads[0].channelId,
-            ])) === null || _a === void 0 ? void 0 : _a.data;
-            if (channel) {
-                callbacks$6.forEach(cb => cb(channel));
-            }
-        };
-        mainDisposer$6 = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
-    }
-    callbacks$6.push(callback);
-    return () => dispose$6(callback);
-};
-
-const callbacks$5 = [];
-let mainDisposer$5 = null;
-const dispose$5 = (cb) => {
-    const index = callbacks$5.indexOf(cb);
-    if (index > -1) {
-        callbacks$5.splice(index, 1);
-    }
-    if (callbacks$5.length === 0) {
-        mainDisposer$5 === null || mainDisposer$5 === void 0 ? void 0 : mainDisposer$5();
-    }
-};
-const onChannelMemberAdded = (callback) => {
-    if (callbacks$5.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const preparedPayload = await prepareChannelPayload(payload);
-            const { channels, channelUsers } = preparedPayload;
-            ingestInCache(preparedPayload);
-            callbacks$5.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'member')));
-        };
-        mainDisposer$5 = createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
-    }
-    callbacks$5.push(callback);
-    return () => dispose$5(callback);
-};
-
-const callbacks$4 = [];
-let mainDisposer$4 = null;
-const dispose$4 = (cb) => {
-    const index = callbacks$4.indexOf(cb);
-    if (index > -1) {
-        callbacks$4.splice(index, 1);
-    }
-    if (callbacks$4.length === 0) {
-        mainDisposer$4 === null || mainDisposer$4 === void 0 ? void 0 : mainDisposer$4();
-    }
-};
-const onChannelMemberRemoved = (callback) => {
-    if (callbacks$4.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const preparedPayload = await prepareChannelPayload(payload);
-            const { channels, channelUsers } = preparedPayload;
-            ingestInCache(preparedPayload);
-            callbacks$4.forEach(cb => cb(channels[0], channelUsers[0]));
-        };
-        mainDisposer$4 = createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
-    }
-    callbacks$4.push(callback);
-    return () => dispose$4(callback);
-};
-
-const callbacks$3 = [];
-let mainDisposer$3 = null;
-const dispose$3 = (cb) => {
-    const index = callbacks$3.indexOf(cb);
-    if (index > -1) {
-        callbacks$3.splice(index, 1);
-    }
-    if (callbacks$3.length === 0) {
-        mainDisposer$3 === null || mainDisposer$3 === void 0 ? void 0 : mainDisposer$3();
-    }
-};
-const onChannelMemberUnbanned = (callback) => {
-    if (callbacks$3.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const preparedPayload = await prepareChannelPayload(payload);
-            const { channels, channelUsers } = preparedPayload;
-            ingestInCache(preparedPayload);
-            callbacks$3.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'none')));
-        };
-        mainDisposer$3 = createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
-    }
-    callbacks$3.push(callback);
-    return () => dispose$3(callback);
-};
-
-const callbacks$2 = [];
-let mainDisposer$2 = null;
-const dispose$2 = (cb) => {
-    const index = callbacks$2.indexOf(cb);
-    if (index > -1) {
-        callbacks$2.splice(index, 1);
-    }
-    if (callbacks$2.length === 0) {
-        mainDisposer$2 === null || mainDisposer$2 === void 0 ? void 0 : mainDisposer$2();
-    }
-};
-const onChannelMemberRoleAdded = (callback) => {
-    if (callbacks$2.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const { channels, channelUsers } = payload;
-            callbacks$2.forEach(cb => cb(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')));
-        };
-        mainDisposer$2 = createEventSubscriber(client, 'onChannelMemberRoleAdded', 'local.channel-moderator.role-added', filter);
-    }
-    callbacks$2.push(callback);
-    return () => dispose$2(callback);
-};
-
-const callbacks$1 = [];
-let mainDisposer$1 = null;
-const dispose$1 = (cb) => {
-    const index = callbacks$1.indexOf(cb);
-    if (index > -1) {
-        callbacks$1.splice(index, 1);
-    }
-    if (callbacks$1.length === 0) {
-        mainDisposer$1 === null || mainDisposer$1 === void 0 ? void 0 : mainDisposer$1();
-    }
-};
-const onChannelMemberRoleRemoved = (callback) => {
-    if (callbacks$1.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payload) => {
-            const { channels, channelUsers } = payload;
-            callback(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member'));
-        };
-        mainDisposer$1 = createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'local.channel-moderator.role-removed', filter);
-    }
-    callbacks$1.push(callback);
-    return () => dispose$1(callback);
-};
-
 /**
  * ```js
  * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
@@ -25890,76 +26085,6 @@ const onMessageMarked = (callback) => {
     return createEventSubscriber(client, 'messageMarker/onMessageMarked', 'marker.marked-message', filter);
 };
 
-/**
- * ```js
- * import { isEqual } from '~/utils/isEqual'
- * const isEqual = isEqual(post1, post2)
- * ```
- *
- * Compares two Amity.Model
- *
- * @param x the Amity.Model to compare
- * @param y the Amity.Model to compare wit x
- * @returns a boolean based on equality
- *
- * @category utility
- * @private
- */
-function isEqual(x, y) {
-    if (x === null || x === undefined || y === null || y === undefined) {
-        return x === y;
-    }
-    // after this just checking type of one would be enough
-    if (x.constructor !== y.constructor) {
-        return false;
-    }
-    // if they are functions, they should exactly refer to same one (because of closures)
-    if (x instanceof Function) {
-        return x === y;
-    }
-    // if they are regexps, they should exactly refer to same one
-    if (x instanceof RegExp) {
-        return x === y;
-    }
-    if (x === y || x.valueOf() === y.valueOf()) {
-        return true;
-    }
-    if (Array.isArray(x) && x.length !== y.length) {
-        return false;
-    }
-    // check each element of the array for equality
-    if (Array.isArray(x) && Array.isArray(y)) {
-        if (x.length !== y.length)
-            return false;
-        for (let i = 0; i < x.length; i += 1) {
-            if (!isEqual(x[i], y[i]))
-                return false;
-        }
-        // if all elements are equal, the arrays are equal
-        return true;
-    }
-    // if they are dates, they must had equal valueOf
-    if (x instanceof Date) {
-        return false;
-    }
-    // if they are strictly equal, they both need to be object at least
-    if (!(x instanceof Object)) {
-        return false;
-    }
-    if (!(y instanceof Object)) {
-        return false;
-    }
-    // recursive object equality check
-    const p = Object.keys(x);
-    return (Object.keys(y).every(i => {
-        // @ts-ignore
-        return p.indexOf(i) !== -1;
-    }) &&
-        p.every(i => {
-            return isEqual(x[i], y[i]);
-        }));
-}
-
 function isObject(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -35677,50 +35802,6 @@ const onUserDeleted$1 = (channelId) => (callback) => {
     return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
 };
 
-const callbacks = [];
-let mainDisposer = null;
-const dispose = (cb) => {
-    const index = callbacks.indexOf(cb);
-    if (index > -1) {
-        callbacks.splice(index, 1);
-    }
-    if (callbacks.length === 0) {
-        mainDisposer === null || mainDisposer === void 0 ? void 0 : mainDisposer();
-    }
-};
-const onChannelSetUserMuted = (callback) => {
-    if (callbacks.length === 0) {
-        const client = getActiveClient();
-        const filter = async (payloads) => {
-            var _a, _b;
-            payloads.forEach(payload => {
-                payload.userIds.forEach(userId => 
-                // If muteTimeout > now => user is muted
-                // Otherwise => user is unmuted
-                upsertInCache(['channelUsers', 'get', `${payload.channelId}#${userId}`], {
-                    isMuted: Date.parse(payload.muteTimeout) > Date.now(),
-                }));
-            });
-            const channel = (_a = pullFromCache([
-                'channel',
-                'get',
-                payloads[0].channelId,
-            ])) === null || _a === void 0 ? void 0 : _a.data;
-            const channelUser = (_b = pullFromCache([
-                'channelUsers',
-                'get',
-                `${payloads[0].channelId}#${payloads[0].userIds[0]}`,
-            ])) === null || _b === void 0 ? void 0 : _b.data;
-            if (channel && channelUser) {
-                callbacks.forEach(cb => cb(channel, channelUser));
-            }
-        };
-        mainDisposer = createEventSubscriber(client, 'onChannelUserMute', 'channel.setUserMuted', filter);
-    }
-    callbacks.push(callback);
-    return () => dispose(callback);
-};
-
 /* eslint-disable no-use-before-define */
 class ChannelMemberLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
@@ -41941,6 +42022,39 @@ const onStreamTerminated = (callback) => {
     return createEventSubscriber(client, 'stream/onStreamTerminated', 'video-streaming.didTerminate', filter);
 };
 
+/**
+ * ```js
+ * import { onStreamViewerUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onStreamViewerBanned(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user in channel linked to stream has been unbanned
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+const onStreamViewerUnbanned = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payloads) => {
+        var _a;
+        // Get new stream object to restore stream watcherUrl in cache
+        await Promise.all(payloads.map(({ streamId }) => getStream(streamId)));
+        const stream = (_a = pullFromCache([
+            'stream',
+            'get',
+            payloads[0].streamId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (!stream)
+            return;
+        callback(stream);
+    };
+    return createEventSubscriber(client, 'stream/onStreamViewerDidUnban', 'video-streaming.viewerDidUnban', filter);
+};
+
 /* eslint-disable no-use-before-define */
 /* begin_public_function
   id: stream.get
@@ -42059,39 +42173,6 @@ class GetStreamsQueryStreamController extends QueryStreamController {
     }
 }
 
-/**
- * ```js
- * import { onStreamViewerUnbanned } from '@amityco/ts-sdk'
- * const dispose = onStreamViewerBanned(stream => {
- *   // ...
- * })
- * ```
- *
- * Fired when a user in channel linked to stream has been unbanned
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Stream Events
- */
-const onStreamViewerUnbanned = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payloads) => {
-        var _a;
-        // Get new stream object to restore stream watcherUrl in cache
-        await Promise.all(payloads.map(({ streamId }) => getStream(streamId)));
-        const stream = (_a = pullFromCache([
-            'stream',
-            'get',
-            payloads[0].streamId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (!stream)
-            return;
-        callback(stream);
-    };
-    return createEventSubscriber(client, 'stream/onStreamViewerDidUnban', 'video-streaming.viewerDidUnban', filter);
-};
-
 class GetStreamsLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
         const queryStreamId = hash(query);
@@ -42189,6 +42270,8 @@ var index$7 = /*#__PURE__*/Object.freeze({
   onStreamRecorded: onStreamRecorded,
   onStreamFlagged: onStreamFlagged,
   onStreamTerminated: onStreamTerminated,
+  onStreamViewerBanned: onStreamViewerBanned,
+  onStreamViewerUnbanned: onStreamViewerUnbanned,
   getStreamById: getStreamById,
   getStreams: getStreams
 });
@@ -42689,7 +42772,8 @@ const USAGE_COLLECTION_INTERVAL = 20 * SECOND;
  *  2. Get the usage collector instance to update usage
  */
 class EventRegister {
-    constructor(player, resolution) {
+    constructor(player, resolution, streamId) {
+        this._SDKUnsubscribers = [];
         this.player = player;
         this.resolution = resolution;
         this._startTime = null;
@@ -42706,10 +42790,20 @@ class EventRegister {
                 mutation.removedNodes.forEach(node => {
                     if (node === player) {
                         this._unregisterEvents();
+                        this._SDKUnsubscribers.forEach(fn => fn === null || fn === void 0 ? void 0 : fn());
                     }
                 });
             });
         });
+        this._SDKUnsubscribers.push(onStreamViewerBanned(stream => {
+            // if still has stream.watcherUrl, the current user has not banned.
+            if (stream.watcherUrl)
+                return;
+            this.player.pause();
+            this.player.removeAttribute('src');
+            this.player.load();
+            this.player.remove();
+        }));
     }
     _resetStartTime() {
         this._startTime = Date.now();
@@ -42832,7 +42926,7 @@ const getPlayer = async (parameters) => {
         }
         video.src = recording.mp4.url;
     }
-    new EventRegister(video, resolution).registerEvents();
+    new EventRegister(video, resolution, streamId).registerEvents();
     return video;
 };