@amityco/ts-sdk 7.5.3-d52ed38.0 → 7.5.3-d6ee46d.0

package/dist/index.esm.js

@@ -25987,266 +25987,6 @@ 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) => {
@@ -26519,6 +26259,33 @@ 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'
@@ -26790,11 +26557,52 @@ 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;
-const isConsistentMode = true;
+let isConsistentMode = true;
 let deviceLastSyncAt = null;
 const getDeviceLastSyncAt = () => {
     if (deviceLastSyncAt == null) {
@@ -26809,6 +26617,12 @@ 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.
@@ -26846,71 +26660,372 @@ const markerSyncTrigger = async () => {
         return;
     }
     try {
-        isWaitingForResponse = true;
-        // any past events are considered processed here.
-        // however during waiting for the response, RTE could add the new message event;
-        // which will make the engine trigger another call next round.
-        events = [];
-        const response = await markerSync(getDeviceLastSyncAt().toISOString());
-        const latestLastSyncAt = response.data.userMarkers.reduce((maxLastSyncAt, userMarker) => {
-            if (maxLastSyncAt == null ||
-                maxLastSyncAt.getTime() < new Date(userMarker.lastSyncAt).getTime()) {
-                return new Date(userMarker.lastSyncAt);
-            }
-            return maxLastSyncAt;
-        }, null);
-        saveDeviceLastSyncAt(latestLastSyncAt);
-        if (response.hasMore) {
-            events.push("has_more" /* Amity.MarkerSyncEvent.HAS_MORE */);
+        isWaitingForResponse = true;
+        // any past events are considered processed here.
+        // however during waiting for the response, RTE could add the new message event;
+        // which will make the engine trigger another call next round.
+        events = [];
+        const response = await markerSync(getDeviceLastSyncAt().toISOString());
+        const latestLastSyncAt = response.data.userMarkers.reduce((maxLastSyncAt, userMarker) => {
+            if (maxLastSyncAt == null ||
+                maxLastSyncAt.getTime() < new Date(userMarker.lastSyncAt).getTime()) {
+                return new Date(userMarker.lastSyncAt);
+            }
+            return maxLastSyncAt;
+        }, null);
+        saveDeviceLastSyncAt(latestLastSyncAt);
+        if (response.hasMore) {
+            events.push("has_more" /* Amity.MarkerSyncEvent.HAS_MORE */);
+        }
+    }
+    catch (_a) {
+        // prevent sync from stopping
+    }
+    finally {
+        if (isWaitingForResponse) {
+            isWaitingForResponse = false;
+        }
+    }
+};
+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;
+};
+/**
+ ```js
+ * import { startUnreadSync } from '@amityco/ts-sdk'
+ * startUnreadSync()
+ * ```
+ *
+ * start syncing to keep feed markers, channel markers and user makers cache
+ * update to the server.
+ *
+ * @category Marker API
+ */
+const startUnreadSync = async () => {
+    await fetchDeviceLastSyncAt();
+    pushMarkerSyncEvent("start syncing" /* Amity.MarkerSyncEvent.START_SYNCING */);
+    enableUnreadCount();
+    isConsistentMode = false;
+    isSyncRunning = true;
+    registerEventListeners();
+};
+/**
+ ```js
+ * import { stopUnreadSync } from '@amityco/ts-sdk'
+ * stopUnreadSync()
+ * ```
+ *
+ * stop unread syncing
+ *
+ * @category Marker API
+ */
+const stopUnreadSync = () => {
+    isSyncRunning = false;
+    setMarkerSyncEvents([]);
+    unRegisterEventListeners();
+};
+setIntervalTask(async () => {
+    if (!isSyncRunning)
+        return;
+    await markerSyncTrigger();
+}, 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 (_a) {
-        // prevent sync from stopping
+    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;
     }
-    finally {
-        if (isWaitingForResponse) {
-            isWaitingForResponse = false;
+    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;
 };
-const unRegisterEventListeners = () => {
-    disposers$1.forEach(fn => fn());
-    disposers$1 = [];
+/* 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);
+        },
+    };
 };
-const startMarkerSync = async () => Promise.resolve();
-/**
- ```js
- * import { startUnreadSync } from '@amityco/ts-sdk'
- * startUnreadSync()
- * ```
+/* 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
  *
- * start syncing to keep feed markers, channel markers and user makers cache
- * update to the server.
+ * @param token to be checked
+ * @returns boolean indicating if token expires
  *
- * @category Marker API
+ * @category private
  */
-const startUnreadSync = async () => Promise.resolve();
-/**
- ```js
- * import { stopUnreadSync } from '@amityco/ts-sdk'
- * stopUnreadSync()
- * ```
+const isExpired = (expiresAt) => Date.now() > Date.parse(expiresAt) - COMPENSATED_DELAY;
+/*
+ * a helper function to check if the token is about to expire
  *
- * stop unread syncing
+ * @param token to be checked
+ * @returns boolean indicating if token is aboutToExpire
  *
- * @category Marker API
+ * @category private
  */
-const stopUnreadSync = () => {
-    isSyncRunning = false;
-    setMarkerSyncEvents([]);
-    unRegisterEventListeners();
+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;
 };
-setIntervalTask(async () => {
-    if (!isSyncRunning)
-        return;
-    await markerSyncTrigger();
-}, SYNC_TRIGGER_INTERVAL_TIME);
-const getMarkerSyncConsistentMode = () => isConsistentMode;
+/*
+ * 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';
 /**
@@ -27057,10 +27172,6 @@ const isConnected = () => {
         isWsConnected);
 };
 
-const enableUnreadCount = () => {
-    return true;
-};
-
 var _GlobalFileAccessType_fileAccessType;
 class GlobalFileAccessType {
     constructor() {