@amityco/ts-sdk-react-native 6.30.2 → 6.30.3

package/dist/index.cjs.js

@@ -122,8 +122,8 @@ const PostContentType = Object.freeze({
 
 function getVersion() {
     try {
-        // the string ''v6.30.2-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v6.30.2-cjs';
+        // the string ''v6.30.3-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v6.30.3-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -7786,52 +7786,48 @@ const deleteChannelUnreadByChannelId = (channelId) => {
     }
 };
 
-/**
- * ```js
- * import { onChannelDeleted } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelDeleted(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} have been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelDeleted = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const data = await prepareChannelPayload(payload);
-        if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-            data.channels.forEach(channel => {
-                addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-                deleteChannelUnreadByChannelId(channel.channelId);
-            });
-        }
-        ingestInCache(data);
-        callback(data.channels[0]);
-    };
-    return createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
+    if (callbacks$b.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const data = await prepareChannelPayload(payload);
+            if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+                data.channels.forEach(channel => {
+                    addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+                    deleteChannelUnreadByChannelId(channel.channelId);
+                });
+            }
+            ingestInCache(data);
+            callbacks$b.forEach(cb => cb(data.channels[0]));
+        };
+        mainDisposer$a = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
+    }
+    callbacks$b.push(callback);
+    return () => dispose$b(callback);
 };
 
-/**
- * ```js
- * import { onChannelMemberBanned } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelMemberBanned((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.InternalUser} has been banned from any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelMemberBanned = (callback) => {
     const client = getActiveClient();
     const filter = async (payload) => {
@@ -7847,9 +7843,11 @@ const onChannelMemberBanned = (callback) => {
             });
         }
         ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers.find(cu => cu.membership === 'banned'));
+        callbacks$a.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'banned')));
     };
-    return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+    mainDisposer$9 = createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+    callbacks$a.push(callback);
+    return () => dispose$a(callback);
 };
 
 function prepareUserPayload(response) {
@@ -8308,274 +8306,269 @@ const removeChannelMarkerCache = (channel) => {
     dropFromCache(['channelMarker', 'get', id], true);
 };
 
-/**
- * ```js
- * import { onChannelCreated } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelCreated(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} have been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+const callbacks$9 = [];
+let mainDisposer$8 = 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$8 === null || mainDisposer$8 === void 0 ? void 0 : mainDisposer$8();
+    }
+};
 const onChannelCreated = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const data = await prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0]);
-    };
-    return createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
+    if (callbacks$9.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const data = await prepareChannelPayload(payload);
+            ingestInCache(data);
+            callbacks$9.forEach(cb => cb(data.channels[0]));
+        };
+        mainDisposer$8 = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
+    }
+    callbacks$9.push(callback);
+    return () => dispose$9(callback);
 };
 
-/**
- * ```js
- * import { onChannelUpdated } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelUpdated(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} have been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+const callbacks$8 = [];
+const mainDisposers = [];
+const dispose$8 = (cb) => {
+    const index = callbacks$8.indexOf(cb);
+    if (index > -1) {
+        callbacks$8.splice(index, 1);
+    }
+    if (callbacks$8.length === 0) {
+        mainDisposers.forEach(fn => fn());
+    }
+};
 const onChannelUpdated = (callback) => {
     const client = getActiveClient();
-    const filter = async (payload) => {
-        const data = await prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0]);
-    };
-    const disposers = [
-        createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter),
-        createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callback(payload.channels[0])),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
+    if (callbacks$8.length === 0) {
+        const filter = async (payload) => {
+            const data = await prepareChannelPayload(payload);
+            ingestInCache(data);
+            callbacks$8.forEach(cb => cb(data.channels[0]));
+        };
+        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter));
+        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$8.forEach(cb => cb(payload.channels[0]))));
+    }
+    callbacks$8.push(callback);
+    return () => dispose$8(callback);
 };
 
-/**
- * ```js
- * import { onChannelJoined } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelJoined((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} was joined
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelJoined = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const preparedPayload = await prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers[0]);
-    };
-    return createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
+    if (callbacks$7.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const preparedPayload = await prepareChannelPayload(payload);
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$7.forEach(cb => cb(channels[0], channelUsers[0]));
+        };
+        mainDisposer$7 = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
+    }
+    callbacks$7.push(callback);
+    return () => dispose$7(callback);
 };
 
-/**
- * ```js
- * import { onChannelLeft } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelLeft((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} was left
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelLeft = (callback) => {
-    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,
-        });
-        if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
-            preparedPayload.channels.forEach(channel => {
-                addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-                deleteChannelUnreadByChannelId(channel.channelId);
+    if (callbacks$6.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 { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers[0]);
-    };
-    return createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+            if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
+                preparedPayload.channels.forEach(channel => {
+                    addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+                    deleteChannelUnreadByChannelId(channel.channelId);
+                });
+            }
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$6.forEach(cb => cb(channels[0], channelUsers[0]));
+        };
+        mainDisposer$6 = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+    }
+    callbacks$6.push(callback);
+    return () => dispose$6(callback);
 };
 
-/**
- * ```js
- * import { onChannelMuted } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelMuted(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} have been muted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelMuted = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const data = await prepareChannelPayload(payload);
-        ingestInCache(data);
-        callback(data.channels[0]);
-    };
-    return createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
+    if (callbacks$5.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const data = await prepareChannelPayload(payload);
+            ingestInCache(data);
+            callbacks$5.forEach(cb => cb(data.channels[0]));
+        };
+        mainDisposer$5 = createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
+    }
+    callbacks$5.push(callback);
+    return () => dispose$5(callback);
 };
 
-/**
- * ```js
- * import { onChannelMemberAdded } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelMemberAdded((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.InternalUser} has been added to any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelMemberAdded = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const preparedPayload = await prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers.find(cu => cu.membership === 'member'));
-    };
-    return createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
+    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.find(cu => cu.membership === 'member')));
+        };
+        mainDisposer$4 = createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
+    }
+    callbacks$4.push(callback);
+    return () => dispose$4(callback);
 };
 
-/**
- * ```js
- * import { onChannelMemberRemoved } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelMemberRemoved((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.InternalUser} has been removed from any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelMemberRemoved = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const preparedPayload = await prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers[0]);
-    };
-    return createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
+    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[0]));
+        };
+        mainDisposer$3 = createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
+    }
+    callbacks$3.push(callback);
+    return () => dispose$3(callback);
 };
 
-/**
- * ```js
- * import { onChannelMemberUnbanned } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelMemberUnbanned((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.InternalUser} has been unbanned from any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelMemberUnbanned = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const preparedPayload = await prepareChannelPayload(payload);
-        const { channels, channelUsers } = preparedPayload;
-        ingestInCache(preparedPayload);
-        callback(channels[0], channelUsers.find(cu => cu.membership === 'none'));
-    };
-    return createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
+    if (callbacks$2.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const preparedPayload = await prepareChannelPayload(payload);
+            const { channels, channelUsers } = preparedPayload;
+            ingestInCache(preparedPayload);
+            callbacks$2.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'none')));
+        };
+        mainDisposer$2 = createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
+    }
+    callbacks$2.push(callback);
+    return () => dispose$2(callback);
 };
 
-/**
- * ```js
- * import { onChannelMemberRoleAdded } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelMemberRoleAdded((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.channelUsers} 's role has been added to any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelMemberRoleAdded = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const { channels, channelUsers } = payload;
-        callback(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member'));
-    };
-    return createEventSubscriber(client, 'onChannelMemberRoleAdded', 'local.channel-moderator.role-added', filter);
+    if (callbacks$1.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const { channels, channelUsers } = payload;
+            callbacks$1.forEach(cb => cb(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')));
+        };
+        mainDisposer$1 = createEventSubscriber(client, 'onChannelMemberRoleAdded', 'local.channel-moderator.role-added', filter);
+    }
+    callbacks$1.push(callback);
+    return () => dispose$1(callback);
 };
 
-/**
- * ```js
- * import { onChannelMemberRoleRemoved } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelMemberRoleRemoved((channel, member) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.channelUsers} 's role has been deleted to any {@link Amity.Channel}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+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 onChannelMemberRoleRemoved = (callback) => {
-    const client = getActiveClient();
-    const filter = async (payload) => {
-        const { channels, channelUsers } = payload;
-        callback(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member'));
-    };
-    return createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'local.channel-moderator.role-removed', filter);
+    if (callbacks.length === 0) {
+        const client = getActiveClient();
+        const filter = async (payload) => {
+            const { channels, channelUsers } = payload;
+            callback(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member'));
+        };
+        mainDisposer = createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'local.channel-moderator.role-removed', filter);
+    }
+    callbacks.push(callback);
+    return () => dispose(callback);
 };
 
 /**