@amityco/ts-sdk-react-native 6.22.1-cbca8f1.0 → 6.23.1-d5c2fe6.0

package/src/core/liveCollection/LiveCollectionController.ts

@@ -1,4 +1,4 @@
-import { convertGetterPropsToStatic } from '~/utils/object';
+import { convertGetterPropsToStatic, removeFunctionProperties } from '~/utils/object';
 import { isEqual } from '~/utils/isEqual';
 import { PaginationController } from './PaginationController';
 import { PaginationNoPageController } from './PaginationNoPageController';
@@ -57,10 +57,13 @@ export abstract class LiveCollectionController<
     }
   }
 
-  protected loadPage(
+  protected loadPage({
     initial = false,
-    direction: Amity.LiveCollectionPageDirection = Amity.LiveCollectionPageDirection.NEXT,
-  ) {
+    direction = Amity.LiveCollectionPageDirection.NEXT,
+  }: {
+    initial?: boolean;
+    direction?: Amity.LiveCollectionPageDirection;
+  }) {
     this.setup();
 
     this.notifyChange({ origin: Amity.LiveDataOrigin.LOCAL, loading: true });
@@ -129,9 +132,10 @@ export abstract class LiveCollectionController<
   abstract notifyChange(params: Amity.LiveCollectionNotifyParams): void;
 
   protected shouldNotify(data: TPublicPayload[]) {
-    if (isEqual(this.snapshot, data)) return false;
+    const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
+    if (isEqual(this.snapshot, newData)) return false;
 
-    this.snapshot = data.map(payload => convertGetterPropsToStatic(payload)) as TPublicPayload[];
+    this.snapshot = newData as TPublicPayload[];
     return true;
   }
 

package/src/fileRepository/api/uploadFile.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { rebuildFormDataWithMimeType } from '~/fileRepository/utils/rebuildFormDataWithMimeType';
 
 /* begin_public_function
   id: file.upload.file
@@ -36,16 +35,12 @@ export const uploadFile = async <T extends Amity.FileType = any>(
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.http.post<Amity.CreateFilePayload<T>>(
-    '/api/v4/files',
-    rebuildFormDataWithMimeType(formData),
-    {
-      headers,
-      onUploadProgress({ loaded, total = 100 }) {
-        onProgress && onProgress(Math.round((loaded * 100) / total));
-      },
+  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
+    headers,
+    onUploadProgress({ loaded, total = 100 }) {
+      onProgress && onProgress(Math.round((loaded * 100) / total));
     },
-  );
+  });
 
   // API-FIX: payload should be serialized properly
   // const { files } = data

package/src/fileRepository/api/uploadImage.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { rebuildFormDataWithMimeType } from '../utils/rebuildFormDataWithMimeType';
 
 /* begin_public_function
   id: file.upload.image
@@ -38,7 +37,7 @@ export const uploadImage = async (
 
   const { data } = await client.http.post<Amity.CreateFilePayload<'image'>>(
     '/api/v4/images',
-    rebuildFormDataWithMimeType(formData),
+    formData,
     {
       headers,
       onUploadProgress({ loaded, total = 100 }) {

package/src/fileRepository/api/uploadVideo.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { rebuildFormDataWithMimeType } from '../utils/rebuildFormDataWithMimeType';
 
 /* begin_public_function
   id: file.upload.video, file.upload.audio
@@ -44,7 +43,7 @@ export const uploadVideo = async (
 
   const { data } = await client.http.post<Amity.CreateFilePayload<'video'>>(
     '/api/v4/videos',
-    rebuildFormDataWithMimeType(formData),
+    formData,
     {
       headers,
       onUploadProgress({ loaded, total = 100 }) {

package/src/marker/events/onChannelUnreadUpdatedLocal.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * Internal used only
+ *
+ * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category MessageMarker Events
+ */
+export const onChannelUnreadUpdatedLocal = (
+  callback: Amity.Listener<Amity.Events['local.channelUnread.updated']>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.channelUnread.updated']) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(
+    client,
+    'channelMarker/onChannelUnreadUpdatedLocal',
+    'local.channelUnread.updated',
+    filter,
+  );
+};

package/src/marker/events/onSubChannelMarkerFetched.ts

@@ -22,7 +22,7 @@ export const onSubChannelMarkerFetched = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.Events['local.subChannelMarker.fetched']) => {
-    callback(payload.userFeedMarkers[0]);
+    payload.userFeedMarkers.forEach(callback);
   };
 
   return createEventSubscriber(

package/src/marker/events/onSubChannelUnreadUpdatedLocal.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * Internal used only
+ *
+ * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category MessageMarker Events
+ */
+export const onSubChannelUnreadUpdatedLocal = (
+  callback: Amity.Listener<Amity.Events['local.subChannelUnread.updated']>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.subChannelUnread.updated']) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(
+    client,
+    'subChannelMarker/onSubChannelUnreadUpdatedLocal',
+    'local.subChannelUnread.updated',
+    filter,
+  );
+};

package/src/marker/events/onUserFeedMarkerUpdated.ts

@@ -23,10 +23,9 @@ export const onUserFeedMarkerUpdated = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.Events['marker.userFeed-updated']) => {
-    // update sub channel unread info and channel unread info in cache
-    persistUnreadCountInfo(payload);
-
-    callback(payload.feedMarkers[0]);
+    payload.feedMarkers.forEach(feedMarker => {
+      callback(feedMarker);
+    });
   };
 
   return createEventSubscriber(

package/src/marker/utils/reCalculateChannelUnreadInfo.ts

@@ -1,7 +1,7 @@
 import { pushToCache, queryCache } from '~/cache/api';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 
-export const reCalculateChannelUnreadInfo = async (channelId: string) => {
+export const reCalculateChannelUnreadInfo = (channelId: string): Amity.ChannelUnreadInfo => {
   const cacheKeyChannelUnread = ['channelUnreadInfo', 'get', channelId];
   const cacheChannelUnreadInfo =
     pullFromCache<Amity.ChannelUnreadInfo>(cacheKeyChannelUnread)?.data;
@@ -25,7 +25,7 @@ export const reCalculateChannelUnreadInfo = async (channelId: string) => {
     isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
   }
 
-  pushToCache(cacheKeyChannelUnread, {
+  const channelUnreadInfo = {
     ...(cacheChannelUnreadInfo ?? {
       channelId,
       createdAt: new Date().toISOString(),
@@ -33,5 +33,9 @@ export const reCalculateChannelUnreadInfo = async (channelId: string) => {
     updatedAt: new Date().toISOString(),
     unreadCount: channelUnreads,
     isMentioned,
-  });
+  };
+
+  pushToCache(cacheKeyChannelUnread, channelUnreadInfo);
+
+  return channelUnreadInfo;
 };

package/src/messagePreview/utils/getChannelMessagePreviewWithUser.ts

@@ -2,7 +2,11 @@ import { pullFromCache } from '~/cache/api';
 import { getChannelMessagePreview } from './getChannelMessagePreview';
 import { LinkedObject } from '~/utils/linkedObject';
 
-export const getChannelMessagePreviewWithUser = (channel: Amity.InternalChannel): Amity.Channel => {
+export const getChannelMessagePreviewWithUser = (
+  channel: Amity.InternalChannel,
+): Amity.InternalChannel & {
+  messagePreview: Amity.MessagePreview | null;
+} => {
   const messagePreview = channel.messagePreviewId
     ? getChannelMessagePreview(channel.channelId)
     : null;

package/src/messageRepository/events/onMessageCreated.ts

@@ -4,6 +4,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareMessagePayload } from '../utils';
 import { updateSubChannelUnreadFromMessage } from '~/marker/utils/updateSubChannelUnreadFromMessage';
 import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
+import { markReadMessage } from '../utils/markReadMessage';
+import { getActiveUser } from '~/client/api/activeUser';
 
 /**
  * ```js
@@ -25,6 +27,7 @@ export const onMessageCreatedMqtt = (
   callback: Amity.Listener<Amity.InternalMessage>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
+  const user = getActiveUser();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {
     const payload = await prepareMessagePayload(rawPayload);
@@ -41,6 +44,7 @@ export const onMessageCreatedMqtt = (
     ingestInCache(payload);
 
     payload.messages.forEach(message => {
+      if (message.creatorPrivateId === user._id) markReadMessage(message);
       callback(message);
     });
   };

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -49,7 +49,7 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     );
 
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {
@@ -107,8 +107,8 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     if (!this.shouldNotify(data) && origin === 'event') return;
 
     this.callback({
-      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
-      onPrevPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.PREV),
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      onPrevPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.PREV }),
       data,
       hasNextPage: !!this.paginationController.getNextToken(),
       hasPrevPage: !!this.paginationController.getPrevToken(),

package/src/messageRepository/utils/markReadMessage.ts

@@ -0,0 +1,8 @@
+import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
+
+export const markReadMessage = (message: Amity.InternalMessage) => {
+  const { subChannelId, channelSegment } = message;
+  const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
+
+  markReadReceiptEngine.markRead(subChannelId, channelSegment);
+};

package/src/postRepository/api/createPost.ts

@@ -26,7 +26,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @category Post API
  * @async
  */
-export const createPost = async <T extends Amity.PostContentType>(
+export const createPost = async <T extends Amity.PostContentType | string>(
   bundle: Pick<Amity.Post<T>, 'targetType' | 'targetId'> &
     Partial<Pick<Amity.Post<T>, 'metadata' | 'mentionees' | 'tags'>> & {
       dataType?: T;
@@ -37,7 +37,6 @@ export const createPost = async <T extends Amity.PostContentType>(
   const client = getActiveClient();
   client.log('post/createPost', bundle);
 
-  // API-FIX: backend rejects that we pass the dataType manually T_T
   if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
     // eslint-disable-next-line no-param-reassign
     delete bundle.dataType;

package/src/postRepository/api/editPost.ts

@@ -47,7 +47,7 @@ export const editPost = async <T extends Amity.PostContentType>(
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('post.updated', data);
+  fireEvent('local.post.updated', data);
 
   const { posts } = data;
 

package/src/postRepository/api/updatePost.ts

@@ -51,7 +51,7 @@ export const updatePost = async <T extends Amity.PostContentType>(
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('post.updated', data);
+  fireEvent('local.post.updated', data);
 
   const { posts } = data;
 

package/src/postRepository/observers/getPost.ts

@@ -13,6 +13,8 @@ import {
 } from '../events';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { LinkedObject } from '~/utils/linkedObject';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
+import { convertEventPayload } from '~/utils/event';
 
 /* begin_public_function
   id: post.get
@@ -80,6 +82,30 @@ export const getPost = (
     },
     onPostUnflagged,
     onPostUpdated,
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentCreated(async (comment: Amity.InternalComment) => {
+          if (comment.referenceId === postId) {
+            await _getPost(postId);
+            callback(comment);
+          }
+        });
+      },
+      'referenceId',
+      'post',
+    ),
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentDeleted(async (comment: Amity.InternalComment) => {
+          if (comment.referenceId === postId) {
+            await _getPost(postId);
+            callback(comment);
+          }
+        });
+      },
+      'referenceId',
+      'post',
+    ),
   ]);
 };
 /* end_public_function */

package/src/postRepository/observers/getPosts.ts

@@ -2,6 +2,7 @@
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client/api';
 import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { getPost as _getPost } from '../api/getPost';
 
 import {
   createQuery,
@@ -34,6 +35,8 @@ import {
   onPostUpdated,
 } from '../events';
 import { queryPosts } from '../api/queryPosts';
+import { convertEventPayload } from '~/utils/event';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
 
 /* begin_public_function
   id: post.query
@@ -204,6 +207,34 @@ export const getPosts = (
     onPostUnflagged(realtimeRouter('onUnflagged')),
     onPostReactionAdded(realtimeRouter('onReactionAdded')),
     onPostReactionRemoved(realtimeRouter('onReactionRemoved')),
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentCreated(async (comment: Amity.InternalComment) => {
+          const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+          if (!currentCollection || currentCollection.data.includes(comment.referenceId)) return;
+
+          await _getPost(comment.referenceId);
+          callback(comment);
+        });
+      },
+      'referenceId',
+      'post',
+    )(realtimeRouter('onUpdate')),
+    convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) => {
+        return onCommentDeleted(async (comment: Amity.InternalComment) => {
+          const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+          if (!currentCollection || currentCollection.data.includes(comment.referenceId)) return;
+
+          await _getPost(comment.referenceId);
+          callback(comment);
+        });
+      },
+      'referenceId',
+      'post',
+    )(realtimeRouter('onUpdate')),
   );
 
   onFetch(true);

package/src/storyRepository/observers/getGlobalStoryTargets/GlobalStoryLiveCollectionController.ts

@@ -48,7 +48,7 @@ export class GlobalStoryLiveCollectionController extends LiveCollectionControlle
 
     this.paginationController = paginationController;
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {
@@ -94,7 +94,7 @@ export class GlobalStoryLiveCollectionController extends LiveCollectionControlle
       ) as Amity.StoryTarget[];
 
     this.callback({
-      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
       data,
       hasNextPage: !!this.paginationController.getNextToken(),
       loading,

package/src/storyRepository/observers/getStoriesByTargetIds/StoryLiveCollectionController.ts

@@ -42,7 +42,7 @@ export class StoryLiveCollectionController extends LiveCollectionController<
 
     this.paginationController = paginationController;
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {

package/src/storyRepository/utils/createOptimisticEvent.ts

@@ -21,32 +21,37 @@ export const createOptimisticEvent = (
 ) => {
   if (formData) {
     const files = formData.getAll('files');
-    const fileObject = (files[0] as File & { uri: string }) || undefined;
+    const fileObject = files[0] || undefined;
 
     if (!fileObject) return;
 
-    return callback(
-      saveOptimisticToCache(
-        isVideo
-          ? {
-              ...payload,
-              data: {
-                ...payload.data,
-                fileId: undefined,
-                videoFileId: { original: undefined },
-                fileData: fileObject.uri,
-              },
-            }
-          : {
-              ...payload,
-              data: {
-                ...payload.data,
-                fileId: undefined,
-                fileData: fileObject.uri,
+    const fileData = new FileReader();
+
+    fileData.readAsDataURL(fileObject as Blob);
+    fileData.onload = () => {
+      return callback(
+        saveOptimisticToCache(
+          isVideo
+            ? {
+                ...payload,
+                data: {
+                  ...payload.data,
+                  fileId: undefined,
+                  videoFileId: { original: undefined },
+                  fileData: fileData?.result,
+                },
+              }
+            : {
+                ...payload,
+                data: {
+                  ...payload.data,
+                  fileId: undefined,
+                  fileData: fileData?.result,
+                },
               },
-            },
-      ),
-    );
+        ),
+      );
+    };
   }
 
   return callback(

package/src/streamRepository/api/getStreams.ts

@@ -8,7 +8,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 */
 /**
  * ```js
- * import { getStreams } from '@amityco/ts-sdk-react-native'
+ * import { getStreams } from '@amityco/ts-sdk'
  * const streams = await getStreams()
  * ```
  *
@@ -62,7 +62,7 @@ export const getStreams = async (query?: {
 
 /**
  * ```js
- * import { getStreams } from '@amityco/ts-sdk-react-native'
+ * import { getStreams } from '@amityco/ts-sdk'
  * const streams = getStreams.locally()
  * ```
  *

package/src/streamRepository/events/onStreamFlagged.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamFlagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onStreamFlagged(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalStream} has started airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamFlagged = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamFlagged',
+    'v3.video-streaming.didFlag',
+    filter,
+  );
+};

package/src/streamRepository/events/onStreamTerminated.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamTerminated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onStreamTerminated(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalStream} has started airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamTerminated = (
+  callback: Amity.Listener<Amity.InternalStream>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamTerminated',
+    'v3.video-streaming.didTerminate',
+    filter,
+  );
+};

package/src/streamRepository/observers/getStreams.ts

@@ -26,7 +26,7 @@ import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
 */
 /**
  * ```js
- * import { StreamRepository } from '@amityco/ts-sdk-react-native'
+ * import { StreamRepository } from '@amityco/ts-sdk'
  * const streams = await StreamRepository.getStreams()
  * ```
  *

package/src/subChannelRepository/observers/getSubChannel.ts

@@ -20,7 +20,7 @@ import { getActiveClient } from '~/client';
 import { getSubChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { isEqual } from '~/utils/isEqual';
 import { updateSubChannelCache } from '../utils/updateSubChannelCache';
-import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
+import { onSubChannelUnreadUpdatedLocal } from '~/marker/events/onSubChannelUnreadUpdatedLocal';
 
 /* begin_public_function
   id: subchannel.get
@@ -135,10 +135,12 @@ export const getSubChannel = (
             updateSubChannelCache(message.subChannelId, subChannel, {
               messagePreviewId: message.messageId,
             });
+          };
 
+          return onMessageCreatedMqtt(async (message: Amity.InternalMessage) => {
+            await updateMessagePreview(message);
             callback(message);
-          };
-          return onMessageCreatedMqtt(updateMessagePreview);
+          });
         },
         'subChannelId',
         'subChannel',
@@ -163,10 +165,12 @@ export const getSubChannel = (
             updateSubChannelCache(message.subChannelId, subChannel, {
               messagePreviewId: message.messageId,
             });
+          };
 
+          return onMessageCreatedLocal(async (message: Amity.InternalMessage) => {
+            await updateMessagePreview(message);
             callback(message);
-          };
-          return onMessageCreatedLocal(updateMessagePreview);
+          });
         },
         'subChannelId',
         'subChannel',
@@ -217,7 +221,7 @@ export const getSubChannel = (
         'subChannelId',
         'subChannel',
       ),
-      convertEventPayload(onUserFeedMarkerUpdated, 'feedId', 'subChannel'),
+      convertEventPayload(onSubChannelUnreadUpdatedLocal, 'subChannelId', 'subChannel'),
     ],
     {
       forceDispatch: true,