@amityco/ts-sdk-react-native 6.30.3-cae094b.0 → 6.30.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "6.30.3-cae094b.0",
+  "version": "6.30.3",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/channelRepository/events/onChannelCreated.ts

@@ -5,30 +5,34 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelCreated = (callback: Amity.Listener<Amity.InternalChannel>) => {
-  const client = getActiveClient();
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelPayload) => {
+      const data = await prepareChannelPayload(payload);
 
-  const filter = async (payload: Amity.ChannelPayload) => {
-    const data = await prepareChannelPayload(payload);
+      ingestInCache(data);
+      callbacks.forEach(cb => cb(data.channels[0]));
+    };
 
-    ingestInCache(data);
-    callback(data.channels[0]);
-  };
+    mainDisposer = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
+  }
 
-  return createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
+  callbacks.push(callback);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelDeleted.ts

@@ -7,37 +7,41 @@ import { prepareChannelPayload } from '../utils/prepareChannelPayload';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelDeleted = (callback: Amity.Listener<Amity.InternalChannel>) => {
-  const client = getActiveClient();
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelPayload) => {
+      const data = await prepareChannelPayload(payload);
 
-  const filter = async (payload: Amity.ChannelPayload) => {
-    const data = await prepareChannelPayload(payload);
+      if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        data.channels.forEach(channel => {
+          addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+          deleteChannelUnreadByChannelId(channel.channelId);
+        });
+      }
 
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-      data.channels.forEach(channel => {
-        addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-        deleteChannelUnreadByChannelId(channel.channelId);
-      });
-    }
+      ingestInCache(data);
+      callbacks.forEach(cb => cb(data.channels[0]));
+    };
 
-    ingestInCache(data);
-    callback(data.channels[0]);
-  };
+    mainDisposer = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
+  }
 
-  return createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
+  callbacks.push(callback);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelFetched.ts

@@ -2,27 +2,36 @@ import { createEventSubscriber } from '~/core/events';
 
 import { getActiveClient } from '~/client/api/activeClient';
 
-/**
- * ```js
- * import { onChannelFetched } from '@amityco/ts-sdk-react-native'
- * const dispose = onChannelFetched(channel => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Channel} list have been fetched
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Channel Events
- */
+type CallbackFn = (channel: Amity.InternalChannel[]) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelFetched = (callback: Amity.Listener<Amity.InternalChannel[]>) => {
-  const client = getActiveClient();
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.InternalChannel[]) => {
+      callbacks.forEach(cb => cb(payload));
+    };
 
-  const filter = async (payload: Amity.InternalChannel[]) => {
-    callback(payload);
-  };
+    mainDisposer = createEventSubscriber(
+      client,
+      'onChannelFetched',
+      'local.channel.fetched',
+      filter,
+    );
+  }
 
-  return createEventSubscriber(client, 'onChannelFetched', 'local.channel.fetched', filter);
+  callbacks.push(callback);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelJoined.ts

@@ -5,33 +5,37 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelJoined = (
   callback: (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void,
 ) => {
-  const client = getActiveClient();
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelMembershipPayload) => {
+      const preparedPayload = await prepareChannelPayload(payload);
+      const { channels, channelUsers } = preparedPayload;
 
-  const filter = async (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = await prepareChannelPayload(payload);
-    const { channels, channelUsers } = preparedPayload;
+      ingestInCache(preparedPayload);
+      callbacks.forEach(cb => cb(channels[0], channelUsers[0]));
+    };
 
-    ingestInCache(preparedPayload);
-    callback(channels[0], channelUsers[0]);
-  };
+    mainDisposer = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
+  }
 
-  return createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
+  callbacks.push(callback);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelLeft.ts

@@ -7,48 +7,53 @@ import { prepareChannelPayload } from '../utils';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelLeft = (
   callback: (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void,
 ) => {
-  const client = getActiveClient();
-
-  const filter = async (payload: Amity.ChannelMembershipPayload) => {
-    const { userId } = getActiveClient();
-    const { channelUsers: leftUsers } = payload;
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
 
-    const isLeftByMe = leftUsers.some(user => user.userId === userId);
+    const filter = async (payload: Amity.ChannelMembershipPayload) => {
+      const { userId } = getActiveClient();
+      const { channelUsers: leftUsers } = payload;
 
-    const preparedPayload = await prepareChannelPayload(payload, {
-      isMessagePreviewUpdated: isLeftByMe,
-    });
+      const isLeftByMe = leftUsers.some(user => user.userId === userId);
 
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
-      preparedPayload.channels.forEach(channel => {
-        addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-        deleteChannelUnreadByChannelId(channel.channelId);
+      const preparedPayload = await prepareChannelPayload(payload, {
+        isMessagePreviewUpdated: isLeftByMe,
       });
-    }
 
-    const { channels, channelUsers } = preparedPayload;
+      if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
+        preparedPayload.channels.forEach(channel => {
+          addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+          deleteChannelUnreadByChannelId(channel.channelId);
+        });
+      }
+
+      const { channels, channelUsers } = preparedPayload;
+
+      ingestInCache(preparedPayload);
+      callbacks.forEach(cb => cb(channels[0], channelUsers[0]));
+    };
+
+    mainDisposer = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+  }
 
-    ingestInCache(preparedPayload);
-    callback(channels[0], channelUsers[0]);
-  };
+  callbacks.push(callback);
 
-  return createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelMemberAdded.ts

@@ -4,33 +4,44 @@ import { createEventSubscriber } from '~/core/events';
 
 import { prepareChannelPayload } from '../utils';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelMemberAdded = (
   callback: (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void,
 ): Amity.Unsubscriber => {
-  const client = getActiveClient();
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelMembershipPayload) => {
+      const preparedPayload = await prepareChannelPayload(payload);
+      const { channels, channelUsers } = preparedPayload;
 
-  const filter = async (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = await prepareChannelPayload(payload);
-    const { channels, channelUsers } = preparedPayload;
+      ingestInCache(preparedPayload);
+      callbacks.forEach(cb =>
+        cb(channels[0], channelUsers.find(cu => cu.membership === 'member')!),
+      );
+    };
 
-    ingestInCache(preparedPayload);
-    callback(channels[0], channelUsers.find(cu => cu.membership === 'member')!);
-  };
+    mainDisposer = createEventSubscriber(
+      client,
+      'onChannelMemberAdded',
+      'channel.membersAdded',
+      filter,
+    );
+  }
 
-  return createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
+  callbacks.push(callback);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelMemberBanned.ts

@@ -7,21 +7,20 @@ import { prepareChannelPayload } from '../utils';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelMemberBanned = (
   callback: (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void,
 ) => {
@@ -47,8 +46,11 @@ export const onChannelMemberBanned = (
     }
 
     ingestInCache(preparedPayload);
-    callback(channels[0], channelUsers.find(cu => cu.membership === 'banned')!);
+    callbacks.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'banned')!));
   };
 
-  return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+  mainDisposer = createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+
+  callbacks.push(callback);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelMemberRemoved.ts

@@ -5,33 +5,42 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelMemberRemoved = (
   callback: (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void,
 ) => {
-  const client = getActiveClient();
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelMembershipPayload) => {
+      const preparedPayload = await prepareChannelPayload(payload);
+      const { channels, channelUsers } = preparedPayload;
 
-  const filter = async (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = await prepareChannelPayload(payload);
-    const { channels, channelUsers } = preparedPayload;
+      ingestInCache(preparedPayload);
+      callbacks.forEach(cb => cb(channels[0], channelUsers[0]));
+    };
 
-    ingestInCache(preparedPayload);
-    callback(channels[0], channelUsers[0]);
-  };
+    mainDisposer = createEventSubscriber(
+      client,
+      'onChannelMemberRemoved',
+      'channel.membersRemoved',
+      filter,
+    );
+  }
 
-  return createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
+  callbacks.push(callback);
+  return () => dispose(callback);
 };

package/src/channelRepository/events/onChannelMemberRoleAdded.ts

@@ -1,35 +1,41 @@
 import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
-/**
- * ```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
- */
+type CallbackFn = (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
 export const onChannelMemberRoleAdded = (
   callback: (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void,
 ): Amity.Unsubscriber => {
-  const client = getActiveClient();
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ProcessedChannelPayload) => {
+      const { channels, channelUsers } = payload;
+      callbacks.forEach(cb =>
+        cb(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')!),
+      );
+    };
 
-  const filter = async (payload: Amity.ProcessedChannelPayload) => {
-    const { channels, channelUsers } = payload;
-    callback(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')!);
-  };
+    mainDisposer = createEventSubscriber(
+      client,
+      'onChannelMemberRoleAdded',
+      'local.channel-moderator.role-added',
+      filter,
+    );
+  }
 
-  return createEventSubscriber(
-    client,
-    'onChannelMemberRoleAdded',
-    'local.channel-moderator.role-added',
-    filter,
-  );
+  callbacks.push(callback);
+  return () => dispose(callback);
 };