@amityco/ts-sdk 7.7.1-9d0f043.0 → 7.7.1-e0c5cdf.0

package/src/@types/domains/liveReaction.ts

@@ -0,0 +1,25 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawLiveReaction = {
+      userId: string; // user's public ID
+      referenceId: string; // post's internal ID
+      referencePublicId: string; // post's public ID
+      referenceType: string; // 'post'
+      reactionName: string; // 'love
+      // date string in ISO format
+      occurredAt: string;
+    };
+
+    type InternalLiveReaction = RawLiveReaction;
+
+    type LiveReaction = InternalLiveReaction;
+
+    type CreateLiveReactionRequest = Omit<RawLiveReaction, 'userId' | 'referenceId' | 'occurredAt'>;
+
+    type CreateLiveReactionResponse = {
+      addedIds: string[];
+    };
+  }
+}

package/src/@types/domains/post.ts

@@ -74,6 +74,7 @@ declare global {
     };
 
     type PostLinkObject = {
+      childrenPosts: Amity.Post[];
       latestComments: (Amity.Comment | null)[];
       creator: Amity.User | undefined;
       analytics: {
@@ -83,6 +84,8 @@ declare global {
       getVideoInfo: () => Amity.File<'video'> | undefined;
       getVideoThumbnailInfo: () => Amity.File<'image'> | undefined;
       getFileInfo: () => Amity.File<'file'> | undefined;
+      getPollInfo: () => Amity.Poll | undefined;
+      getLivestreamInfo: () => Amity.Stream | undefined;
       getClipInfo: () => Amity.File<'clip'> | undefined;
     };
 

package/src/@types/domains/stream.ts

@@ -73,6 +73,12 @@ declare global {
        */
       targetId?: string; // communityId, userId, etc..
       targetType?: string; // 'community', 'user', etc..
+      /*
+       * when stream linked with a post and a live channel.
+       */
+      postId?: string;
+      channelId?: string;
+      channelEnabled?: boolean;
     } & Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete;
@@ -81,9 +87,14 @@ declare global {
 
     type StreamLinkedObject = {
       moderation?: Amity.StreamModeration;
+      post?: Amity.InternalPost;
+      getLiveChat: () => Promise<Amity.Channel<'live'> | undefined>;
     };
 
-    type Stream = Amity.InternalStream & Amity.StreamLinkedObject;
+    type Stream = Omit<Amity.InternalStream & Amity.StreamLinkedObject, 'watcherUrl'> & {
+      isBanned: boolean;
+      watcherUrl: null;
+    };
 
     type QueryStreams = {
       isLive?: boolean;

package/src/@types/index.ts

@@ -43,3 +43,4 @@ export * from './domains/invitation';
 export * from './domains/joinRequest';
 export * from './domains/pin';
 export * from './domains/pinnedPost';
+export * from './domains/liveReaction';

package/src/channelRepository/api/createChannel.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+import { constructChannelObject } from '../utils/constructChannelObject';
 
 /* begin_public_function
   id: channel.create
@@ -23,11 +23,14 @@ import { constructChannelDynamicValue } from '../utils/constructChannelDynamicVa
  * @async
  */
 export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: { type: T; userIds?: Amity.InternalUser['userId'][] } & Pick<
-    Amity.Channel<T>,
-    'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'
-  >,
-): Promise<Amity.Cached<Amity.InternalChannel>> => {
+  bundle: {
+    type: T;
+    userIds?: Amity.InternalUser['userId'][];
+    // For live channel linked with a livestream post
+    videoStreamId?: string;
+    postId?: string;
+  } & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'>,
+): Promise<Amity.Cached<Amity.Channel<T>>> => {
   const client = getActiveClient();
   client.log('user/createChannel', bundle);
 
@@ -53,7 +56,7 @@ export const createChannel = async <T extends Amity.ChannelType>(
 
   const { channels } = data;
   return {
-    data: constructChannelDynamicValue(channels[0]),
+    data: constructChannelObject(channels[0]),
     cachedAt,
   };
 };

package/src/channelRepository/channelMembership/observers/getMembers/ChannelMemberLiveCollectionController.ts

@@ -24,6 +24,7 @@ import {
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
 import { LinkedObject } from '~/utils/linkedObject';
+import { onChannelSetUserMuted } from '~/channelRepository/events/onChannelSetUserMuted';
 
 export class ChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -89,6 +90,7 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
       { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
       { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+      { fn: onChannelSetUserMuted, action: 'onChannelSetUserMuted' },
       { fn: onUserDeleted(this.query.channelId), action: 'onChannelMemberChanged' },
     ]);
   }

package/src/channelRepository/events/index.ts

@@ -4,7 +4,7 @@ export * from './onChannelDeleted';
 
 export * from './onChannelJoined';
 export * from './onChannelLeft';
-export * from './onChannelMuted';
+export * from './onChannelSetMuted';
 
 export * from './onChannelMemberAdded';
 export * from './onChannelMemberRemoved';

package/src/channelRepository/events/onChannelSetMuted.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+
+type CallbackFn = Amity.Listener<Amity.StaticInternalChannel>;
+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 onChannelSetMuted = (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payloads: Amity.ChannelSetMutedPayload) => {
+      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 = pullFromCache<Amity.StaticInternalChannel>([
+        'channel',
+        'get',
+        payloads[0].channelId,
+      ])?.data;
+
+      if (channel) {
+        callbacks.forEach(cb => cb(channel));
+      }
+    };
+
+    mainDisposer = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/events/onChannelSetUserMuted.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { pullFromCache, upsertInCache } from '~/cache/api';
+
+type CallbackFn = (
+  channel: Amity.StaticInternalChannel,
+  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 onChannelSetUserMuted = (
+  callback: (channel: Amity.StaticInternalChannel, member: Amity.Membership<'channel'>) => void,
+): Amity.Unsubscriber => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelSetUserMutedPayload) => {
+      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 = pullFromCache<Amity.StaticInternalChannel>([
+        'channel',
+        'get',
+        payload.channelId,
+      ])?.data;
+
+      const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+        'channelUsers',
+        'get',
+        `${payload.channelId}#${payload.userIds[0]}`,
+      ])?.data;
+
+      if (channel && channelUser) {
+        callbacks.forEach(cb => cb(channel, channelUser));
+      }
+    };
+
+    mainDisposer = createEventSubscriber(
+      client,
+      'onChannelUserMute',
+      'channel.setMutedUsers',
+      filter,
+    );
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/internalApi/getChannel.ts

@@ -9,7 +9,6 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareChannelPayload } from '../utils';
 import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js

package/src/channelRepository/internalApi/getMyMembership.ts

@@ -0,0 +1,37 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { ASCApiError } from '~/core/errors';
+
+/**
+ *
+ * get current user's membership data
+ *
+ * @returns the {@link Amity.Membership<'channel'>} objects
+ *
+ * @category Channel API
+ * @async
+ */
+
+export const getMyMembership = (channelId: string): Amity.Cached<Amity.Membership<'channel'>> => {
+  const client = getActiveClient();
+  client.log('channel/getMyMembership.locally');
+
+  const cacheChannelUser = pullFromCache<Amity.Membership<'channel'>>([
+    'channelUsers',
+    'get',
+    `${channelId}#${client.userId}`,
+  ]);
+
+  if (!cacheChannelUser) {
+    throw new ASCApiError(
+      'Item not found!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+  }
+
+  return {
+    data: cacheChannelUser.data,
+    cachedAt: cacheChannelUser.cachedAt,
+  };
+};

package/src/channelRepository/observers/getChannel.ts

@@ -10,7 +10,7 @@ import {
   onChannelMemberBanned,
   onChannelMemberRemoved,
   onChannelMemberUnbanned,
-  onChannelMuted,
+  onChannelSetMuted,
   onChannelUpdated,
 } from '../events';
 import { dropFromCache, pullFromCache } from '~/cache/api';
@@ -104,7 +104,7 @@ export const getChannel = (
       onChannelMemberRemoved,
       onChannelMemberBanned,
       onChannelMemberUnbanned,
-      onChannelMuted,
+      onChannelSetMuted,
       convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
       convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
       convertEventPayload(

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -11,7 +11,6 @@ import {
   onChannelLeft,
   onChannelMemberAdded,
   onChannelMemberRemoved,
-  onChannelMuted,
   onChannelUpdated,
 } from '~/channelRepository/events';
 import {
@@ -58,6 +57,7 @@ import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFe
 import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
 import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
 import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
+import { onChannelSetMuted } from '~/channelRepository/events/onChannelSetMuted';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -313,7 +313,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       { fn: onChannelDeleted, action: Amity.ChannelActionType.OnDelete },
       { fn: onChannelUpdated, action: Amity.ChannelActionType.OnUpdate },
-      { fn: onChannelMuted, action: Amity.ChannelActionType.OnMute },
+      { fn: onChannelSetMuted, action: Amity.ChannelActionType.OnMute },
       {
         fn: (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
           return onChannelJoined(channel => {

package/src/channelRepository/observers/getMyMembership.ts

@@ -0,0 +1,98 @@
+import { getActiveUser } from '~/client/api/activeUser';
+import { getMyMembership as _getMyMembership } from '../internalApi/getMyMembership';
+import { ASCApiError, ASCError } from '~/core/errors';
+import { getActiveClient } from '~/client/api/activeClient';
+import { isEqual } from '~/utils/isEqual';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
+import { channelMemberLinkedObject } from '~/utils/linkedObject/channelMemberLinkedObject';
+import { onChannelMemberBanned, onChannelMemberUnbanned } from '../events';
+import { onChannelSetUserMuted } from '../events/onChannelSetUserMuted';
+
+export const getMyMembership = (
+  channelId: string,
+  callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>,
+): Amity.Unsubscriber => {
+  const { _id: userId } = getActiveUser();
+
+  if (!userId)
+    throw new ASCError(
+      'The _id has not been defined in ActiveUser',
+      Amity.ClientError.UNKNOWN_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: Amity.Unsubscriber[] = [];
+
+  let isUnsyncedModel = false; // for messages
+
+  let model: Amity.Membership<'channel'> | undefined;
+
+  const dispatcher = (data: Amity.LiveObject<Amity.Membership<'channel'> | undefined>) => {
+    callback({
+      ...data,
+      data: data.data ? channelMemberLinkedObject(data.data) : data.data,
+    });
+  };
+
+  const realtimeRouter = (_: Amity.StaticInternalChannel, __: Amity.RawMembership<'channel'>) => {
+    const { data } = _getMyMembership(channelId);
+
+    if (isEqual(model, data)) return;
+
+    dispatcher({
+      loading: false,
+      data,
+    });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(async () => _getMyMembership(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,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            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());
+  };
+};

package/src/channelRepository/utils/constructChannelObject.ts

@@ -1,6 +1,6 @@
 import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { constructChannelDynamicValue } from './constructChannelDynamicValue';
-import { LinkedObject } from '~/utils/linkedObject';
+import { channelLinkedObject } from '~/utils/linkedObject/channelLinkedObject';
 
 export const constructChannelObject = (channel: Amity.StaticInternalChannel): Amity.Channel => {
   /**
@@ -10,7 +10,7 @@ export const constructChannelObject = (channel: Amity.StaticInternalChannel): Am
    * 3. [LinkedObject.channel] add markAsRead >> Amity.InternalChannel -> Amity.Channel
    */
 
-  return LinkedObject.channel(
+  return channelLinkedObject(
     constructChannelDynamicValue(getChannelMessagePreviewWithUser(channel)),
   );
 };

package/src/client/api/login.ts

@@ -13,6 +13,7 @@ import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLog
 import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
 import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
 import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
+import reactionSyncEngineOnLoginHandler from '~/liveReactionRepository/utils/ReactionSyncEngineOnLoginHandler';
 import { logout } from './logout';
 
 import { getActiveClient } from './activeClient';
@@ -201,6 +202,7 @@ export const login = async (
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
       objectResolverEngineOnLoginHandler(),
+      reactionSyncEngineOnLoginHandler(),
     );
 
     if (client.useLegacyUnreadCount) {

package/src/core/events.ts

@@ -32,7 +32,10 @@ const MQTT_EVENTS = [
   'video-streaming.didFlag',
   'video-streaming.didTerminate',
 
-  // 'user.didGlobalBan' remove due to message event,
+  'video-streaming.viewerDidBan',
+  'video-streaming.viewerDidUnban',
+
+  'liveReaction.created',
 ] as const;
 
 /** @hidden */

package/src/core/subscription.ts

@@ -154,6 +154,16 @@ export const getSmartFeedMessageTopic = (): string => {
   return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
 };
 
+export const getLiveStreamTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/videostreaming`;
+};
+
+export const getLiveReactionTopic = (post: Amity.Post) => {
+  return `${post.path}/liveReaction`;
+};
+
 let mqttAccessToken: string;
 let mqttUserId: string;
 
@@ -168,9 +178,3 @@ export function subscribeTopic(
 
   return mqtt.subscribe(topic, callback);
 }
-
-export const getLiveStreamTopic = (): string => {
-  const user = getActiveUser();
-
-  return `${getNetworkId(user)}/videostreaming`;
-};

package/src/index.ts

@@ -53,3 +53,5 @@ export * from './external/api';
 export * as notificationTray from './notificationTray';
 
 export * as InvitationRepository from './invitationRepository';
+
+export * as LiveReactionRepository from './liveReactionRepository';

package/src/liveReactionRepository/api/createReaction.ts

@@ -0,0 +1,58 @@
+import { fireEvent } from '~/core/events';
+import ReactionSyncEngine from '../service/ReactionSyncEngine';
+
+import { getActiveClient } from '~/client/api/activeClient';
+// TODO: confirm id
+/* begin_public_function
+  id: live_reaction.create
+*/
+/**
+ * ```js
+ * import { acceptInvitation } from '@amityco/ts-sdk'
+ * const isAccepted = await acceptInvitation(invitationId)
+ * ```
+ *
+ *
+ * @param referenceId that is target post's ID linked with a livestream
+ * @param reactionName that is the reaction name
+ * @param streamId stream id
+ * @returns a success boolean if the reaction was added
+ *
+ * @category Live Reaction API
+ * @async
+ */
+export const createReaction = async ({
+  referenceId,
+  referenceType,
+  reactionName,
+  streamId,
+}: Pick<Amity.CreateLiveReactionRequest, 'referenceType' | 'reactionName'> & {
+  referenceId: string;
+  streamId: string;
+}): Promise<boolean> => {
+  const client = getActiveClient();
+
+  client.log('live_reaction/createReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  const reactionSynceEngine = ReactionSyncEngine.getInstance();
+
+  const reaction = {
+    reactionName,
+    referencePublicId: referenceId,
+    referenceType,
+    streamId,
+    occurredAt: new Date().toISOString(),
+  };
+
+
+  reactionSynceEngine.createLiveReaction(reaction);
+
+  fireEvent('local.liveReaction.created', [{ ...reaction, userId: client.userId!, referenceId }]);
+
+  return true;
+};
+/* end_public_function */

package/src/liveReactionRepository/api/index.ts

@@ -0,0 +1 @@
+export * from './createReaction';

package/src/liveReactionRepository/events/index.ts

@@ -0,0 +1 @@
+export * from './onLiveReactionCreated';

package/src/liveReactionRepository/events/onLiveReactionCreated.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+/**
+ * ```js
+ * import { onLiveReactionCreated } from '@amityco/ts-sdk'
+ * const dispose = onLiveReactionCreated(reactions => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a batch of {@link Amity.LiveReaction} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Live Reaction Events
+ */
+export const onLiveReactionCreated = (
+  callback: Amity.Listener<Amity.LiveReaction[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.LiveReactionPayload) => {
+    if (rawPayload.reactions.length > 0) {
+      // TODO: check with BE if user id is internal or pulbic id
+      const filteredPayload = rawPayload.reactions.filter(({ userId }) => userId !== client.userId);
+      callback(filteredPayload);
+    }
+  };
+
+  return createEventSubscriber(
+    client,
+    'live_reaction/onLiveReactionCreated',
+    'liveReaction.created',
+    filter,
+  );
+};

package/src/liveReactionRepository/events/onLiveReactionCreatedLocal.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+/**
+ * ```js
+ * import { onLiveReactionCreatedLocal } from '@amityco/ts-sdk'
+ * const dispose = onLiveReactionCreatedLocal(reactions => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a batch of {@link Amity.LiveReaction} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Live Reaction Events
+ */
+export const onLiveReactionCreatedLocal = (
+  callback: Amity.Listener<Amity.LiveReaction[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(
+    client,
+    'live_reaction/onLiveReactionCreated',
+    'local.liveReaction.created',
+    callback,
+  );
+};

package/src/liveReactionRepository/index.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './events';
+export * from './observers';