@amityco/ts-sdk 7.5.3-d6ee46d.0 → 7.5.4-2d34fd5f.0

package/dist/index.esm.js

@@ -18,6 +18,7 @@ const FileType = Object.freeze({
     FILE: 'file',
     IMAGE: 'image',
     VIDEO: 'video',
+    CLIP: 'clip',
 });
 const VideoResolution = Object.freeze({
     '1080P': '1080p',
@@ -101,6 +102,7 @@ const PostContentType = Object.freeze({
     VIDEO: 'video',
     LIVESTREAM: 'liveStream',
     POLL: 'poll',
+    CLIP: 'clip',
 });
 
 var InvitationTypeEnum;
@@ -136,8 +138,8 @@ var JoinResultStatusEnum;
 
 function getVersion() {
     try {
-        // the string ''v7.5.2-esm'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.5.2-esm';
+        // the string ''v7.5.3-esm'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.5.3-esm';
     }
     catch (error) {
         return '__dev__';
@@ -22783,6 +22785,13 @@ function isAmityVideoPost(post) {
         'videoFileId' in post.data &&
         'thumbnailFileId' in post.data &&
         post.dataType === 'video');
+}
+function isAmityClipPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'fileId' in post.data &&
+        'thumbnailFileId' in post.data &&
+        post.dataType === 'clip');
 }
 
 const postLinkedObject = (post) => {
@@ -22837,6 +22846,12 @@ const postLinkedObject = (post) => {
             return isAmityFilePost(post)
                 ? (_b = pullFromCache(['file', 'get', (_a = post === null || post === void 0 ? void 0 : post.data) === null || _a === void 0 ? void 0 : _a.fileId])) === null || _b === void 0 ? void 0 : _b.data
                 : undefined;
+        },
+        getClipInfo() {
+            var _a, _b;
+            return isAmityClipPost(post)
+                ? (_b = pullFromCache(['file', 'get', (_a = post === null || post === void 0 ? void 0 : post.data) === null || _a === void 0 ? void 0 : _a.fileId])) === null || _b === void 0 ? void 0 : _b.data
+                : undefined;
         } });
 };
 
@@ -23817,7 +23832,7 @@ class PaginationController {
  */
 class JoinRequestsPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, communityId } = queryParams, params = __rest(queryParams, ["limit", "communityId"]);
+        const { limit = 20, communityId } = queryParams, params = __rest(queryParams, ["limit", "communityId"]);
         const options = token ? { token } : { limit };
         const { data: queryResponse } = await this.http.get(`/api/v4/communities/${communityId}/join`, {
             params: Object.assign(Object.assign({}, params), { options }),
@@ -25987,6 +26002,266 @@ const removeChannelMarkerCache = (channel) => {
     dropFromCache(['channelMarker', 'get', id], true);
 };
 
+/* eslint-disable no-param-reassign */
+/*
+ * declared earlier to accomodate case when logging in with a different user
+ * than the one already connected, in which case the existing subscriptions need
+ * to be cleared
+ */
+let subscriptions = [];
+async function runMqtt() {
+    await modifyMqttConnection();
+}
+/* begin_public_function
+  id: client.login
+*/
+/**
+ * ```js
+ * import { login } from '@amityco/ts-sdk/client/api'
+ * const success = await login({
+ *   userId: 'XYZ123456789',
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers
+ *
+ * @param params the connect parameters
+ * @param params.userId the user ID for the current session
+ * @param params.displayName the user's displayName for the current session
+ * @param params.deviceId Manual override of the user's device id (for device management)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+const login = async (params, sessionHandler, config) => {
+    var _a;
+    const client = getActiveClient();
+    let unsubWatcher;
+    client.log('client/api/connectClient', Object.assign({ apiKey: client.apiKey, sessionState: client.sessionState }, params));
+    // if connecting to a different userId than the one that is connected currently
+    if (client.userId && client.userId !== params.userId) {
+        await logout();
+        // Remove subscription to ban and delete
+        subscriptions.forEach(fn => fn());
+        subscriptions = [];
+    }
+    // default values
+    const defaultDeviceId = await getDeviceId();
+    try {
+        const { users } = await setClientToken({
+            params: Object.assign(Object.assign({}, params), { displayName: params === null || params === void 0 ? void 0 : params.displayName, deviceId: (params === null || params === void 0 ? void 0 : params.deviceId) || defaultDeviceId }),
+            options: {
+                setAccessTokenCookie: true,
+            },
+        });
+        const user = users.find(u => u.userId === params.userId);
+        if (user == null) {
+            throw new ASCError(`${params.userId} has not been founded`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        }
+        if (user.isDeleted) {
+            terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
+            return false;
+        }
+        if (user.isGlobalBanned) {
+            terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
+            return false;
+        }
+        // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+        // wire websocket events to our event emitter
+        proxyWebsocketEvents(client.ws, client.emitter);
+        (_a = client.ws) === null || _a === void 0 ? void 0 : _a.open();
+        client.userId = user.userId;
+        client.sessionHandler = sessionHandler;
+        /*
+         * Cannot push to subscriptions as watcher needs to continue working even if
+         * token expires
+         */
+        unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
+        setActiveUser(user);
+    }
+    catch (error) {
+        /*
+         * if getting token failed session state reverts to initial state when app
+         * is first launched
+         */
+        SessionWatcher$1.getInstance().setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
+        // pass error down tree so the calling function handle it
+        throw error;
+    }
+    if ((config === null || config === void 0 ? void 0 : config.disableRTE) !== true) {
+        runMqtt();
+    }
+    await initializeMessagePreviewSetting();
+    if (subscriptions.length === 0) {
+        subscriptions.push(
+        // GLOBAL_BAN
+        onClientBanned((_) => {
+            terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
+            subscriptions.forEach(fn => fn());
+            unsubWatcher();
+        }), onTokenTerminated(_ => {
+            terminateClient();
+            subscriptions.forEach(fn => fn());
+            unsubWatcher();
+        }), onUserDeleted$2((user) => {
+            if (user.userId === client.userId) {
+                terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
+                subscriptions.forEach(fn => fn());
+                unsubWatcher();
+            }
+        }), onTokenExpired(state => {
+            SessionWatcher$1.getInstance().setSessionState(state);
+            logout();
+            subscriptions.forEach(fn => fn());
+        }), 
+        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
+        // the channel because currently backend can't handle this, so every time a user is banned from
+        // a channel or the channel is deleted the channel's unread count will not be reset to zero
+        onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler());
+        if (client.useLegacyUnreadCount) {
+            subscriptions.push(readReceiptSyncEngineOnLoginHandler());
+        }
+        else
+            subscriptions.push(legacyReadReceiptSyncEngineOnLoginHandler());
+    }
+    return true;
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: client.renew_access_token
+*/
+/*
+ * Renewal defintion accepted by SessionHandler interface
+ *
+ * Tech Spec:
+ * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-Handler
+ *
+ * @category private
+ */
+const renewal = () => {
+    let tokenRenewed = false;
+    let renewTimeoutId;
+    const client = getActiveClient();
+    client.log('initiating access token renewal');
+    /*
+     * Renews a token if it is hasn't been renewed before. Also marks token as
+     * renewed once done
+     * Per instance of Renewal, only one renewal is allowed
+     */
+    const renewToken = async (authToken) => {
+        const { userId, displayName } = getActiveUser();
+        const deviceId = await getDeviceId();
+        const params = { userId, displayName, authToken, deviceId };
+        if (client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.sessionHandler) {
+            await login(params, client.sessionHandler);
+        }
+        else {
+            // about to expire
+            await setClientToken({
+                params,
+                options: {
+                    setAccessTokenCookie: true,
+                },
+            });
+        }
+        tokenRenewed = true;
+        if (renewTimeoutId)
+            clearTimeout(renewTimeoutId);
+    };
+    return {
+        renew: () => {
+            if (tokenRenewed) {
+                console.log("'renew' method can be called only once per renewal instance");
+                return;
+            }
+            renewToken();
+        },
+        renewWithAuthToken: (authToken) => {
+            if (tokenRenewed) {
+                console.log("'renewWithAuthToken' method can be called only once per renewal instance");
+                return;
+            }
+            renewToken(authToken);
+        },
+        unableToRetrieveAuthToken: () => {
+            renewTimeoutId = setTimeout(() => {
+                var _a;
+                (_a = client.sessionHandler) === null || _a === void 0 ? void 0 : _a.sessionWillRenewAccessToken(renewal());
+            }, ACCESS_TOKEN_WATCHER_INTERVAL);
+        },
+    };
+};
+/* end_public_function */
+
+const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
+const COMPENSATED_DELAY = 5 * MINUTE;
+/*
+ * a helper function to check if the token has expires
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token expires
+ *
+ * @category private
+ */
+const isExpired = (expiresAt) => Date.now() > Date.parse(expiresAt) - COMPENSATED_DELAY;
+/*
+ * a helper function to check if the token is about to expire
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token is aboutToExpire
+ *
+ * @category private
+ */
+const isAboutToExpire = (params) => {
+    const { expiresAt, issuedAt } = params;
+    const expires = Date.parse(expiresAt);
+    const issued = Date.parse(issuedAt);
+    const now = Date.now();
+    const duration = expires - issued - COMPENSATED_DELAY;
+    const aboutToExpireAt = issued + duration * ABOUT_TO_EXPIRE_THRESHOLD;
+    return now > aboutToExpireAt && now < expires;
+};
+/*
+ * Monitors time to expire of token and updates session state to aboutToExpire
+ *
+ * @returns intervalId to be cleared after trigger
+ *
+ * @category private
+ */
+const accessTokenExpiryWatcher = (sessionHandler) => {
+    const interval = setInterval(() => {
+        const client = getActiveClient();
+        if (!client.token)
+            return;
+        const { issuedAt, expiresAt } = client.token;
+        if (isExpired(expiresAt)) {
+            /*
+             * the event handler will take care of updating session state
+             * Note, this will also clear the interval id, so this event will only be
+             * fired once
+             */
+            fireEvent('tokenExpired', "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */);
+            /*
+             * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Automatically-initiate-renewal-flow
+             *
+             * Why sechduled task?
+             * Since fireEvent is scheduled, it will be called
+             * after sessionHandler leading to an invalid state change from
+             * establishing to tokenExpired
+             */
+            scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
+            return;
+        }
+        if (isAboutToExpire({ expiresAt, issuedAt })) {
+            sessionHandler.sessionWillRenewAccessToken(renewal());
+        }
+    }, ACCESS_TOKEN_WATCHER_INTERVAL);
+    return () => clearInterval(interval);
+};
+
 const callbacks$9 = [];
 let mainDisposer$8 = null;
 const dispose$9 = (cb) => {
@@ -26259,33 +26534,6 @@ const onChannelMemberRoleRemoved = (callback) => {
     return () => dispose(callback);
 };
 
-/**
- * ```js
- * import { onUserMarkerSync } from '@amityco/ts-sdk'
- * const dispose = onUserMarkerSync(UserMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.UserMarker} has been sync
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category UserMarker Events
- */
-const onUserMarkerSync = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        const { userMarkers, userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload } = payload, rest = __rest(payload, ["userMarkers", "userEntityMarkers", "userFeedMarkers"]);
-        const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
-        const userFeedMarker = convertSubChannelMarkerResponse(userFeedMarkersPayload);
-        ingestInCache(Object.assign({ userMarkers, userEntityMarkers, userFeedMarker }, rest));
-        callback(userMarkers[0]);
-    };
-    return createEventSubscriber(client, 'UserMarker/onUserMarkerSync', 'marker.user-sync', filter);
-};
-
 /**
  * ```js
  * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
@@ -26557,52 +26805,11 @@ const markerSync = async (deviceLastSyncAt) => {
     };
 };
 
-const enableUnreadCount = () => {
-    const client = getActiveClient();
-    client.log('client/api/isUnreadCountEnabled', client.isUnreadCountEnabled);
-    if (!client) {
-        throw new ASCError('There is no active client', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
-    }
-    if (client.isUnreadCountEnabled)
-        return false;
-    client.isUnreadCountEnabled = true;
-    client.useLegacyUnreadCount = false;
-    client.emitter.emit('unreadCountEnabled', true);
-    return true;
-};
-
-/**
- * ```js
- * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
- * const dispose = onFeedMarkerUpdated(feedMarker => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.UserFeedMarker} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category FeedMarker Events
- */
-const onUserFeedMarkerUpdated = (callback) => {
-    const client = getActiveClient();
-    const filter = (payload) => {
-        persistUnreadCountInfo(payload);
-        payload.feedMarkers.forEach(feedMarker => {
-            callback(feedMarker);
-        });
-    };
-    return createEventSubscriber(client, 'feedMarker/onUserFeedMarkerUpdated', 'marker.userFeed-updated', filter);
-};
-
 const SYNC_TRIGGER_INTERVAL_TIME = 2000;
-const ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY = 2000;
 let isSyncRunning = false;
 let disposers$1 = [];
 let isWaitingForResponse = false;
-let isConsistentMode = true;
+const isConsistentMode = true;
 let deviceLastSyncAt = null;
 const getDeviceLastSyncAt = () => {
     if (deviceLastSyncAt == null) {
@@ -26617,12 +26824,6 @@ const saveDeviceLastSyncAt = (lastSyncAt) => {
         deviceLastSyncAt = lastSyncAt;
     }
 };
-const fetchDeviceLastSyncAt = async () => {
-    const { data: userMarker } = await getUserMarker();
-    if (userMarker == null)
-        return;
-    saveDeviceLastSyncAt(new Date(userMarker.lastSyncAt));
-};
 /**
  * list of conditions that make timer still trigger the syncing process.
  * If it's empty, it means sync is stopped.
@@ -26687,43 +26888,11 @@ const markerSyncTrigger = async () => {
         }
     }
 };
-const registerEventListeners = () => {
-    if (disposers$1.length > 0) {
-        return;
-    }
-    // based on the tech spec design, we designed a fetch marker in case of these events
-    // - new message
-    // - create channel
-    // - remove channel
-    // - app going to online again after offline
-    disposers$1.push(onOnline(() => {
-        // should add RESUME to the event to trigger marker syncing again
-        events.push("resume" /* Amity.MarkerSyncEvent.RESUME */);
-    }), onMessageCreatedMqtt(message => {
-        // only conversation, community and broadcast types can sync
-        const client = getActiveClient();
-        if (isUnreadCountSupport$1(message) && message.creatorId !== client.userId)
-            events.push("new message" /* Amity.MarkerSyncEvent.NEW_MESSAGE */);
-    }), onChannelCreated(() => events.push("subchannel is created" /* Amity.MarkerSyncEvent.CHANNEL_CREATED */)), onChannelDeleted(() => events.push("subchannel is deleted" /* Amity.MarkerSyncEvent.CHANNEL_DELETED */)), onChannelJoined(() => events.push("subchannel is joined" /* Amity.MarkerSyncEvent.CHANNEL_JOINED */)), onChannelLeft(() => events.push("subchannel is left" /* Amity.MarkerSyncEvent.CHANNEL_LEFT */)), onSubChannelCreated(() => events.push("subchannel is created" /* Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED */)), onSubChannelDeleted(() => 
-    /*
-     workaround: when receiving the event for sub-channel deletion,
-     before triggering marker update, the SDK will have to add a 2-second delay.
-     so that the unread count is calculated correctly.
-    */
-    setTimeout(() => events.push("subchannel is deleted" /* Amity.MarkerSyncEvent.SUBCHANNEL_IS_DELETED */), ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY)), onFeedMarkerUpdated(() => events.push("feed marker updated" /* Amity.MarkerSyncEvent.MARKER_UPDATED */)), onUserMarkerSync(() => events.push("feed marker updated" /* Amity.MarkerSyncEvent.MARKER_UPDATED */)), onUserFeedMarkerUpdated(() => events.push("feed marker updated" /* Amity.MarkerSyncEvent.MARKER_UPDATED */)));
-};
 const unRegisterEventListeners = () => {
     disposers$1.forEach(fn => fn());
     disposers$1 = [];
 };
-const startMarkerSync = async () => {
-    await fetchDeviceLastSyncAt();
-    pushMarkerSyncEvent("start syncing" /* Amity.MarkerSyncEvent.START_SYNCING */);
-    isConsistentMode = true;
-    isSyncRunning = true;
-    registerEventListeners();
-    return unRegisterEventListeners;
-};
+const startMarkerSync = async () => Promise.resolve();
 /**
  ```js
  * import { startUnreadSync } from '@amityco/ts-sdk'
@@ -26735,14 +26904,7 @@ const startMarkerSync = async () => {
  *
  * @category Marker API
  */
-const startUnreadSync = async () => {
-    await fetchDeviceLastSyncAt();
-    pushMarkerSyncEvent("start syncing" /* Amity.MarkerSyncEvent.START_SYNCING */);
-    enableUnreadCount();
-    isConsistentMode = false;
-    isSyncRunning = true;
-    registerEventListeners();
-};
+const startUnreadSync = async () => Promise.resolve();
 /**
  ```js
  * import { stopUnreadSync } from '@amityco/ts-sdk'
@@ -26765,268 +26927,6 @@ setIntervalTask(async () => {
 }, SYNC_TRIGGER_INTERVAL_TIME);
 const getMarkerSyncConsistentMode = () => isConsistentMode;
 
-/* eslint-disable no-param-reassign */
-/*
- * declared earlier to accomodate case when logging in with a different user
- * than the one already connected, in which case the existing subscriptions need
- * to be cleared
- */
-let subscriptions = [];
-async function runMqtt() {
-    await modifyMqttConnection();
-}
-/* begin_public_function
-  id: client.login
-*/
-/**
- * ```js
- * import { login } from '@amityco/ts-sdk/client/api'
- * const success = await login({
- *   userId: 'XYZ123456789',
- * })
- * ```
- *
- * Connects an {@link Amity.Client} instance to ASC servers
- *
- * @param params the connect parameters
- * @param params.userId the user ID for the current session
- * @param params.displayName the user's displayName for the current session
- * @param params.deviceId Manual override of the user's device id (for device management)
- * @param params.authToken The authentication token - necessary when network option is set to secure
- * @returns a success boolean if connected
- *
- * @category Client API
- * @async
- */
-const login = async (params, sessionHandler, config) => {
-    var _a;
-    const client = getActiveClient();
-    let unsubWatcher;
-    client.log('client/api/connectClient', Object.assign({ apiKey: client.apiKey, sessionState: client.sessionState }, params));
-    // if connecting to a different userId than the one that is connected currently
-    if (client.userId && client.userId !== params.userId) {
-        await logout();
-        // Remove subscription to ban and delete
-        subscriptions.forEach(fn => fn());
-        subscriptions = [];
-    }
-    // default values
-    const defaultDeviceId = await getDeviceId();
-    try {
-        const { users } = await setClientToken({
-            params: Object.assign(Object.assign({}, params), { displayName: params === null || params === void 0 ? void 0 : params.displayName, deviceId: (params === null || params === void 0 ? void 0 : params.deviceId) || defaultDeviceId }),
-            options: {
-                setAccessTokenCookie: true,
-            },
-        });
-        const user = users.find(u => u.userId === params.userId);
-        if (user == null) {
-            throw new ASCError(`${params.userId} has not been founded`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-        }
-        if (user.isDeleted) {
-            terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
-            return false;
-        }
-        if (user.isGlobalBanned) {
-            terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
-            return false;
-        }
-        // FIXME: events are duplicated if connectClient is called few times without disconnectClient
-        // wire websocket events to our event emitter
-        proxyWebsocketEvents(client.ws, client.emitter);
-        (_a = client.ws) === null || _a === void 0 ? void 0 : _a.open();
-        client.userId = user.userId;
-        client.sessionHandler = sessionHandler;
-        /*
-         * Cannot push to subscriptions as watcher needs to continue working even if
-         * token expires
-         */
-        unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
-        setActiveUser(user);
-    }
-    catch (error) {
-        /*
-         * if getting token failed session state reverts to initial state when app
-         * is first launched
-         */
-        SessionWatcher$1.getInstance().setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
-        // pass error down tree so the calling function handle it
-        throw error;
-    }
-    if ((config === null || config === void 0 ? void 0 : config.disableRTE) !== true) {
-        runMqtt();
-    }
-    await initializeMessagePreviewSetting();
-    if (subscriptions.length === 0) {
-        subscriptions.push(
-        // GLOBAL_BAN
-        onClientBanned((_) => {
-            terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
-            subscriptions.forEach(fn => fn());
-            unsubWatcher();
-        }), onTokenTerminated(_ => {
-            terminateClient();
-            subscriptions.forEach(fn => fn());
-            unsubWatcher();
-        }), onUserDeleted$2((user) => {
-            if (user.userId === client.userId) {
-                terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
-                subscriptions.forEach(fn => fn());
-                unsubWatcher();
-            }
-        }), onTokenExpired(state => {
-            SessionWatcher$1.getInstance().setSessionState(state);
-            logout();
-            subscriptions.forEach(fn => fn());
-        }), 
-        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
-        // the channel because currently backend can't handle this, so every time a user is banned from
-        // a channel or the channel is deleted the channel's unread count will not be reset to zero
-        onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler());
-        if (client.useLegacyUnreadCount) {
-            subscriptions.push(readReceiptSyncEngineOnLoginHandler());
-        }
-        else
-            subscriptions.push(legacyReadReceiptSyncEngineOnLoginHandler());
-        const markerSyncUnsubscriber = await startMarkerSync();
-        subscriptions.push(markerSyncUnsubscriber);
-    }
-    return true;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: client.renew_access_token
-*/
-/*
- * Renewal defintion accepted by SessionHandler interface
- *
- * Tech Spec:
- * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-Handler
- *
- * @category private
- */
-const renewal = () => {
-    let tokenRenewed = false;
-    let renewTimeoutId;
-    const client = getActiveClient();
-    client.log('initiating access token renewal');
-    /*
-     * Renews a token if it is hasn't been renewed before. Also marks token as
-     * renewed once done
-     * Per instance of Renewal, only one renewal is allowed
-     */
-    const renewToken = async (authToken) => {
-        const { userId, displayName } = getActiveUser();
-        const deviceId = await getDeviceId();
-        const params = { userId, displayName, authToken, deviceId };
-        if (client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ && client.sessionHandler) {
-            await login(params, client.sessionHandler);
-        }
-        else {
-            // about to expire
-            await setClientToken({
-                params,
-                options: {
-                    setAccessTokenCookie: true,
-                },
-            });
-        }
-        tokenRenewed = true;
-        if (renewTimeoutId)
-            clearTimeout(renewTimeoutId);
-    };
-    return {
-        renew: () => {
-            if (tokenRenewed) {
-                console.log("'renew' method can be called only once per renewal instance");
-                return;
-            }
-            renewToken();
-        },
-        renewWithAuthToken: (authToken) => {
-            if (tokenRenewed) {
-                console.log("'renewWithAuthToken' method can be called only once per renewal instance");
-                return;
-            }
-            renewToken(authToken);
-        },
-        unableToRetrieveAuthToken: () => {
-            renewTimeoutId = setTimeout(() => {
-                var _a;
-                (_a = client.sessionHandler) === null || _a === void 0 ? void 0 : _a.sessionWillRenewAccessToken(renewal());
-            }, ACCESS_TOKEN_WATCHER_INTERVAL);
-        },
-    };
-};
-/* end_public_function */
-
-const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
-const COMPENSATED_DELAY = 5 * MINUTE;
-/*
- * a helper function to check if the token has expires
- *
- * @param token to be checked
- * @returns boolean indicating if token expires
- *
- * @category private
- */
-const isExpired = (expiresAt) => Date.now() > Date.parse(expiresAt) - COMPENSATED_DELAY;
-/*
- * a helper function to check if the token is about to expire
- *
- * @param token to be checked
- * @returns boolean indicating if token is aboutToExpire
- *
- * @category private
- */
-const isAboutToExpire = (params) => {
-    const { expiresAt, issuedAt } = params;
-    const expires = Date.parse(expiresAt);
-    const issued = Date.parse(issuedAt);
-    const now = Date.now();
-    const duration = expires - issued - COMPENSATED_DELAY;
-    const aboutToExpireAt = issued + duration * ABOUT_TO_EXPIRE_THRESHOLD;
-    return now > aboutToExpireAt && now < expires;
-};
-/*
- * Monitors time to expire of token and updates session state to aboutToExpire
- *
- * @returns intervalId to be cleared after trigger
- *
- * @category private
- */
-const accessTokenExpiryWatcher = (sessionHandler) => {
-    const interval = setInterval(() => {
-        const client = getActiveClient();
-        if (!client.token)
-            return;
-        const { issuedAt, expiresAt } = client.token;
-        if (isExpired(expiresAt)) {
-            /*
-             * the event handler will take care of updating session state
-             * Note, this will also clear the interval id, so this event will only be
-             * fired once
-             */
-            fireEvent('tokenExpired', "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */);
-            /*
-             * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Automatically-initiate-renewal-flow
-             *
-             * Why sechduled task?
-             * Since fireEvent is scheduled, it will be called
-             * after sessionHandler leading to an invalid state change from
-             * establishing to tokenExpired
-             */
-            scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
-            return;
-        }
-        if (isAboutToExpire({ expiresAt, issuedAt })) {
-            sessionHandler.sessionWillRenewAccessToken(renewal());
-        }
-    }, ACCESS_TOKEN_WATCHER_INTERVAL);
-    return () => clearInterval(interval);
-};
-
 const DEFAULT_DEBUG_SESSION = 'amity';
 /**
  * ```js
@@ -27172,6 +27072,10 @@ const isConnected = () => {
         isWsConnected);
 };
 
+const enableUnreadCount = () => {
+    return true;
+};
+
 var _GlobalFileAccessType_fileAccessType;
 class GlobalFileAccessType {
     constructor() {
@@ -29323,10 +29227,10 @@ class BlockedUserLiveCollectionController extends LiveCollectionController {
  * const unblockedUser = await UserRepository.blockUser('userId')
  * ```
  *
- * Blocks a {@link Amity.InternalUser}
+ * Blocks a {@link Amity.User}
  *
- * @param params The params to get blocked {@link Amity.InternalUser}s
- * @param callback to recieve updates on unblocked {@link Amity.InternalUser}s
+ * @param params The params to get blocked {@link Amity.User}s
+ * @param callback to recieve updates on unblocked {@link Amity.User}s
  * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
  *
  * @category Post API
@@ -29918,6 +29822,57 @@ const updateAltText = async (fileId, altText) => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: file.upload.clip
+*/
+/**
+ * ```js
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadClip(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File}
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File}
+ *
+ * @category File API
+ * @async
+ */
+const uploadClip = async (formData, feedType, onProgress) => {
+    const client = getActiveClient();
+    client.log('file/uploadClip', formData);
+    const file = formData.get('files');
+    if (!file)
+        throw new Error('The formData object must have a `files` key.');
+    const accessType = GlobalFileAccessType$1.getInstance().getFileAccessType();
+    formData.append('accessType', accessType);
+    formData.append('preferredFilename', file.name);
+    if (feedType) {
+        formData.append('feedType', feedType);
+    }
+    const headers = 'getHeaders' in formData
+        ? formData.getHeaders()
+        : { 'content-type': 'multipart/form-data' };
+    const { data } = await client.upload.post('/api/v4/clips', formData, {
+        headers,
+        onUploadProgress({ loaded, total = 100 }) {
+            onProgress && onProgress(Math.round((loaded * 100) / total));
+        },
+    });
+    // API-FIX: payload should be serialized properly
+    // const { files } = data
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ files: data }, { cachedAt });
+    return {
+        data,
+        cachedAt,
+    };
+};
+/* end_public_function */
+
 var index$k = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getFile: getFile,
@@ -29926,7 +29881,8 @@ var index$k = /*#__PURE__*/Object.freeze({
   fileUrlWithSize: fileUrlWithSize,
   uploadVideo: uploadVideo,
   uploadImage: uploadImage,
-  updateAltText: updateAltText
+  updateAltText: updateAltText,
+  uploadClip: uploadClip
 });
 
 /**
@@ -30170,7 +30126,7 @@ const getPost$2 = async (postId) => {
     const { posts } = data;
     const result = posts.find(post => post.postId === postId);
     return {
-        data: LinkedObject.post(result),
+        data: result,
         cachedAt,
     };
 };
@@ -30196,7 +30152,7 @@ getPost$2.locally = (postId) => {
     if (!cached)
         return;
     return {
-        data: LinkedObject.post(cached.data),
+        data: cached.data,
         cachedAt: cached.cachedAt,
     };
 };
@@ -30357,7 +30313,7 @@ const prepareCommentFromFlaggedEvent = (payload) => {
  * @async
  * */
 const addReaction = async (referenceType, referenceId, reactionName) => {
-    var _a, _b;
+    var _a, _b, _c;
     const client = getActiveClient();
     client.log('reaction/createReaction', {
         referenceId,
@@ -30378,9 +30334,9 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
             'get',
             referenceId,
         ]);
-        if (!model)
+        if (!model || ((_a = model.data.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)))
             return true;
-        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_a = model.data.myReactions) !== null && _a !== void 0 ? _a : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_b = model.data.reactions[reactionName]) !== null && _b !== void 0 ? _b : 0) + 1 }) });
+        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_b = model.data.myReactions) !== null && _b !== void 0 ? _b : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_c = model.data.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) + 1 }) });
         if (referenceType === 'comment') {
             fireEvent('local.comment.addReaction', {
                 comment: updatedModel,
@@ -35811,7 +35767,7 @@ const getCommunity$1 = async (communityId, type, includeDiscoverablePrivateCommu
     }
     const { communities } = data;
     return {
-        data: LinkedObject.community(communities.find(community => community.communityId === communityId)),
+        data: communities.find(community => community.communityId === communityId),
         cachedAt,
     };
 };
@@ -35837,7 +35793,7 @@ getCommunity$1.locally = (communityId) => {
     if (!cached)
         return;
     return {
-        data: LinkedObject.community(cached.data),
+        data: cached.data,
         cachedAt: cached.cachedAt,
     };
 };
@@ -35873,7 +35829,7 @@ const deleteCommunity = async (communityId) => {
         files: [],
         users: [],
     });
-    return deleted.data;
+    return LinkedObject.community(deleted.data);
 };
 /* end_public_function */
 
@@ -37383,7 +37339,11 @@ const getCommunity = (communityId, callback) => {
         onCommunityUserUnbanned,
         onCommunityUserChanged,
         convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
-    ]);
+    ], {
+        callbackDataSelector: (data) => {
+            return LinkedObject.community(data);
+        },
+    });
 };
 /* end_public_function */
 
@@ -38522,14 +38482,14 @@ var index$a = /*#__PURE__*/Object.freeze({
 const queryGlobalFeed = async (query) => {
     const client = getActiveClient();
     client.log('feed/queryGlobalFeed', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { queryToken } = _a, params = __rest(_a, ["queryToken"]);
+    const _a = query !== null && query !== void 0 ? query : {}, { queryToken, dataTypes, resolveParent } = _a, params = __rest(_a, ["queryToken", "dataTypes", "resolveParent"]);
     const options = (() => {
         if (queryToken)
             return { token: queryToken };
         return undefined;
     })();
     const { data: queryPayload } = await client.http.get(`/api/v4/me/global-feeds`, {
-        params: Object.assign(Object.assign({}, params), { options }),
+        params: Object.assign(Object.assign({}, params), { dataTypes, resolveParent: resolveParent !== null && resolveParent !== void 0 ? resolveParent : true, options }),
     });
     const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
     const data = prepareMembershipPayload(payload, 'communityUsers');
@@ -39115,6 +39075,46 @@ const isPostFlaggedByMe = async (postId) => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: post.create.clip_post
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createClipPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   dataType: 'clip',
+ *   data: { text: 'hello world' },
+ *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Post}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
+ *
+ * @category Post API
+ * @async
+ */
+const createClipPost = async (bundle) => {
+    const client = getActiveClient();
+    client.log('post/createPost', bundle);
+    const { data: payload } = await client.http.post('/api/v4/posts', bundle);
+    fireEvent('post.created', payload);
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    return {
+        data: LinkedObject.post(posts[0]),
+        cachedAt,
+    };
+};
+/* end_public_function */
+
 /* begin_public_function
   id: comment.get_by_ids
 */
@@ -40163,12 +40163,12 @@ const getPost$1 = (postId, callback) => {
         onPostFlagged,
         (callback) => {
             return onPostReactionAdded((post) => {
-                callback(LinkedObject.post(post));
+                callback(post);
             });
         },
         (callback) => {
             return onPostReactionRemoved((post) => {
-                callback(LinkedObject.post(post));
+                callback(post);
             });
         },
         onPostUnflagged,
@@ -40203,7 +40203,7 @@ class PostPaginationController extends PaginationController {
             type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
         };
         const options = token ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { limit });
-        const { data: queryResponse } = await this.http.get(`/api/v4/posts`, {
+        const { data: queryResponse } = await this.http.get(`/api/v5/posts`, {
             params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), 
                 /*
                  * when creating post like image, file, video BE will create 2 posts
@@ -41015,6 +41015,7 @@ var index$7 = /*#__PURE__*/Object.freeze({
   flagPost: flagPost,
   unflagPost: unflagPost,
   isPostFlaggedByMe: isPostFlaggedByMe,
+  createClipPost: createClipPost,
   onPostCreated: onPostCreated,
   onPostUpdated: onPostUpdated,
   onPostDeleted: onPostDeleted,