@amityco/ts-sdk 7.17.1-1f0ca75.0 → 7.17.1-239ff56.0

package/dist/client/api/setupLoginSubscriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupLoginSubscriptions.d.ts","sourceRoot":"","sources":["../../../src/client/api/setupLoginSubscriptions.ts"],"names":[],"mappings":"AAkBA;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,iBAAkB,MAAM,YAAY,KAAG,MAAM,YAAY,EA2D5F,CAAC"}
+{"version":3,"file":"setupLoginSubscriptions.d.ts","sourceRoot":"","sources":["../../../src/client/api/setupLoginSubscriptions.ts"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,iBAAkB,MAAM,YAAY,KAAG,MAAM,YAAY,EA4D5F,CAAC"}

package/dist/commentRepository/events/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/commentRepository/events/utils.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,4BAA4B,UAChC,MAAM,MAAM,iBAAiB,YAC1B,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,uBA0FhD,CAAC;AAEF,eAAO,MAAM,iCAAiC,UACrC,MAAM,KACX,MAAM,kBAAkB,EACxB,2BAA2B,GAAG,8BAA8B,CAC7D,YACS,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,uBAmIhD,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/commentRepository/events/utils.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,4BAA4B,UAChC,MAAM,MAAM,iBAAiB,YAC1B,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,uBA0FhD,CAAC;AAEF,eAAO,MAAM,iCAAiC,UACrC,MAAM,KACX,MAAM,kBAAkB,EACxB,2BAA2B,GAAG,8BAA8B,CAC7D,YACS,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,uBAqIhD,CAAC"}

package/dist/communityRepository/communityMembership/observers/getMembers/CommunityMembersPaginationController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CommunityMembersPaginationController.d.ts","sourceRoot":"","sources":["../../../../../src/communityRepository/communityMembership/observers/getMembers/CommunityMembersPaginationController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAGlF;;;GAGG;AACH,qBAAa,oCAAqC,SAAQ,oBAAoB,CAC5E,eAAe,EACf,KAAK,CAAC,6BAA6B,CACpC;IACO,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,6BAA6B,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS;CAiB7F"}
+{"version":3,"file":"CommunityMembersPaginationController.d.ts","sourceRoot":"","sources":["../../../../../src/communityRepository/communityMembership/observers/getMembers/CommunityMembersPaginationController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAGlF;;;GAGG;AACH,qBAAa,oCAAqC,SAAQ,oBAAoB,CAC5E,eAAe,EACf,KAAK,CAAC,6BAA6B,CACpC;IACO,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,6BAA6B,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS;CAsB7F"}

package/dist/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersPaginationController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SearchCommunityMembersPaginationController.d.ts","sourceRoot":"","sources":["../../../../../src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersPaginationController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAGlF;;;GAGG;AACH,qBAAa,0CAA2C,SAAQ,oBAAoB,CAClF,eAAe,EACf,KAAK,CAAC,mCAAmC,CAC1C;IACO,UAAU,CACd,WAAW,EAAE,KAAK,CAAC,mCAAmC,EACtD,KAAK,EAAE,MAAM,GAAG,SAAS;CAkB5B"}
+{"version":3,"file":"SearchCommunityMembersPaginationController.d.ts","sourceRoot":"","sources":["../../../../../src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersPaginationController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAGlF;;;GAGG;AACH,qBAAa,0CAA2C,SAAQ,oBAAoB,CAClF,eAAe,EACf,KAAK,CAAC,mCAAmC,CAC1C;IACO,UAAU,CACd,WAAW,EAAE,KAAK,CAAC,mCAAmC,EACtD,KAAK,EAAE,MAAM,GAAG,SAAS;CAuB5B"}

package/dist/index.cjs.js

@@ -1848,13 +1848,13 @@ class NetworkActivitiesWatcher {
         this._listener.clear();
     }
 }
-let instance$8;
+let instance$9;
 var NetworkActivitiesWatcher$1 = {
     getInstance: () => {
-        if (!instance$8) {
-            instance$8 = new NetworkActivitiesWatcher();
+        if (!instance$9) {
+            instance$9 = new NetworkActivitiesWatcher();
         }
-        return instance$8;
+        return instance$9;
     },
 };
 
@@ -6915,13 +6915,13 @@ class SessionWatcher {
         this._listener.clear();
     }
 }
-let instance$7;
+let instance$8;
 var SessionWatcher$1 = {
     getInstance: () => {
-        if (!instance$7) {
-            instance$7 = new SessionWatcher();
+        if (!instance$8) {
+            instance$8 = new SessionWatcher();
         }
-        return instance$7;
+        return instance$8;
     },
 };
 
@@ -7983,13 +7983,13 @@ class AnalyticsEngine {
         this._eventCapturer.resetAllBuckets();
     }
 }
-let instance$6;
+let instance$7;
 var AnalyticsEngine$1 = {
     getInstance: () => {
-        if (!instance$6) {
-            instance$6 = new AnalyticsEngine();
+        if (!instance$7) {
+            instance$7 = new AnalyticsEngine();
         }
-        return instance$6;
+        return instance$7;
     },
 };
 
@@ -8217,12 +8217,12 @@ class MessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$5 = null;
+let instance$6 = null;
 var ReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$5)
-            instance$5 = new MessageReadReceiptSyncEngine();
-        return instance$5;
+        if (!instance$6)
+            instance$6 = new MessageReadReceiptSyncEngine();
+        return instance$6;
     },
 };
 
@@ -8476,12 +8476,12 @@ class LegacyMessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$4 = null;
+let instance$5 = null;
 var LegacyReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$4)
-            instance$4 = new LegacyMessageReadReceiptSyncEngine();
-        return instance$4;
+        if (!instance$5)
+            instance$5 = new LegacyMessageReadReceiptSyncEngine();
+        return instance$5;
     },
 };
 
@@ -8727,12 +8727,12 @@ class ObjectResolverEngine {
         this.stopResolver();
     }
 }
-let instance$3 = null;
+let instance$4 = null;
 var ObjectResolverEngine$1 = {
     getInstance: () => {
-        if (!instance$3)
-            instance$3 = new ObjectResolverEngine();
-        return instance$3;
+        if (!instance$4)
+            instance$4 = new ObjectResolverEngine();
+        return instance$4;
     },
 };
 
@@ -8882,13 +8882,13 @@ class LiveReactionSyncEngine {
         this.stopReactionsSync();
     }
 }
-let instance$2;
+let instance$3;
 var ReactionSyncEngine = {
     getInstance: () => {
-        if (!instance$2) {
-            instance$2 = new LiveReactionSyncEngine();
+        if (!instance$3) {
+            instance$3 = new LiveReactionSyncEngine();
         }
-        return instance$2;
+        return instance$3;
     },
 };
 
@@ -8910,6 +8910,148 @@ var reactionSyncEngineOnLoginHandler = () => {
     };
 };
 
+function prepareBlockedUserPayload(response) {
+    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
+    return Object.assign(Object.assign({}, rest), { follows: follows.map(follow => {
+            const followUser = users.find(user => user.userId === follow.from);
+            return Object.assign(Object.assign({}, follow), { user: convertRawUserToInternalUser(followUser) });
+        }), users: users.map(convertRawUserToInternalUser) });
+}
+
+const BLOCK_LIST_LIMIT = 100;
+const TTL_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Session-scoped singleton engine that manages TTL-based fetching and caching
+ * of blocked users. Provides a lazy `ensureFetched()` gate for the
+ * `getAllBlockedUsers()` API.
+ *
+ * Key behaviours:
+ * - `establish()` is a no-op — fetch is lazy, triggered only by consumer call
+ * - `destroy()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
+ * - `ensureFetched()` fetches from server only when cache is expired or never fetched
+ * - `lastFetchedAt` is only updated on successful fetch
+ * - `blockedUserIds` is kept in sync with each successful fetch
+ *
+ * @internal
+ */
+class BlockedUserSyncEngine {
+    constructor() {
+        /** Epoch ms of last successful fetch. null = never fetched in this session. */
+        this.lastFetchedAt = null;
+        /** Ordered list of userId strings from the most recent successful fetch. */
+        this.blockedUserIds = [];
+    }
+    // ---------------------------------------------------------------------------
+    // SessionComponent lifecycle
+    // ---------------------------------------------------------------------------
+    /** No-op — fetch is lazy, triggered by consumer calling getAllBlockedUsers(). */
+    // eslint-disable-next-line class-methods-use-this
+    onSessionEstablished() {
+        // intentionally empty
+    }
+    /** Resets state so the next session starts with a cold cache. */
+    onSessionDestroyed() {
+        this.lastFetchedAt = null;
+        this.blockedUserIds = [];
+    }
+    /** No-op for this engine. */
+    // eslint-disable-next-line class-methods-use-this
+    onTokenExpired() {
+        // intentionally empty
+    }
+    // ---------------------------------------------------------------------------
+    // Cache helpers
+    // ---------------------------------------------------------------------------
+    isCacheExpired() {
+        if (this.lastFetchedAt === null)
+            return true;
+        return Date.now() - this.lastFetchedAt > TTL_MS;
+    }
+    // ---------------------------------------------------------------------------
+    // Core fetch gate
+    // ---------------------------------------------------------------------------
+    /**
+     * Ensures the local store is populated with fresh blocked-user data.
+     *
+     * - If the cache is still within the 5-minute TTL window: resolves immediately
+     *   (no server call).
+     * - If the cache is expired (or never fetched): fetches from the server,
+     *   persists the payload to the cache, and updates `lastFetchedAt`.
+     *
+     * On failure the error propagates to the caller and `lastFetchedAt` is NOT
+     * updated, so the next call will retry.
+     */
+    async ensureFetched() {
+        if (!this.isCacheExpired())
+            return;
+        const client = getActiveClient();
+        const { data } = await client.http.get('/api/v4/me/user-blocks', { params: { options: { limit: BLOCK_LIST_LIMIT }, isDeleted: false } });
+        const cachedAt = client.cache && Date.now();
+        const payload = prepareBlockedUserPayload(data);
+        if (client.cache) {
+            ingestInCache(payload, { cachedAt });
+        }
+        // Keep the ordered list of blocked user IDs for getCachedUsers()
+        this.blockedUserIds = payload.users.map(u => u.userId);
+        // Only update timestamp on success — failure leaves it unchanged so the
+        // next call retries.
+        this.lastFetchedAt = Date.now();
+    }
+    // ---------------------------------------------------------------------------
+    // Local store read
+    // ---------------------------------------------------------------------------
+    /**
+     * Returns blocked {@link Amity.InternalUser} objects from the in-memory cache.
+     *
+     * Applies the spec-mandated filter:
+     *  - Only users whose `isDeleted` is false or null
+     *  - Hard limit of 100 results
+     *
+     * This always reads the latest local state, so changes made by `blockUser()`
+     * and `unblockUser()` are reflected even within the TTL window.
+     */
+    getCachedUsers() {
+        const client = getActiveClient();
+        if (!client.cache) {
+            // No cache available — fall back to the in-memory list from the last fetch
+            return [];
+        }
+        return this.blockedUserIds
+            .map(id => { var _a; return (_a = pullFromCache(['user', 'get', id])) === null || _a === void 0 ? void 0 : _a.data; })
+            .filter((user) => user != null && user.isDeleted !== true)
+            .slice(0, BLOCK_LIST_LIMIT);
+    }
+}
+// ---------------------------------------------------------------------------
+// Module-level singleton
+// ---------------------------------------------------------------------------
+let instance$2 = null;
+var BlockedUserSyncEngine$1 = {
+    getInstance: () => {
+        if (!instance$2)
+            instance$2 = new BlockedUserSyncEngine();
+        return instance$2;
+    },
+};
+
+var blockedUserSyncEngineOnLoginHandler = () => {
+    const blockedUserSyncEngine = BlockedUserSyncEngine$1.getInstance();
+    onSessionStateChange(state => {
+        if (state === "established" /* Amity.SessionStates.ESTABLISHED */) {
+            blockedUserSyncEngine.onSessionEstablished();
+        }
+        else if (state === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            blockedUserSyncEngine.onTokenExpired();
+        }
+        else {
+            blockedUserSyncEngine.onSessionDestroyed();
+        }
+    });
+    return () => {
+        blockedUserSyncEngine.onSessionDestroyed();
+    };
+};
+
 const EVENTS = [
     'disconnected',
     'error',
@@ -9075,7 +9217,7 @@ const setupLoginSubscriptions = (unsubWatcher) => {
     // 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(), reactionSyncEngineOnLoginHandler());
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler());
     if (client.useLegacyUnreadCount) {
         subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
@@ -15564,56 +15706,32 @@ const isUserFlaggedByMe = async (userId) => {
 };
 /* end_public_function */
 
-function prepareBlockedUserPayload(response) {
-    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
-    return Object.assign(Object.assign({}, rest), { follows: follows.map(follow => {
-            const followUser = users.find(user => user.userId === follow.from);
-            return Object.assign(Object.assign({}, follow), { user: convertRawUserToInternalUser(followUser) });
-        }), users: users.map(convertRawUserToInternalUser) });
-}
-
-const BLOCK_LIST_DEFAULT_PAGE_LIMIT = 100;
 /* begin_public_function
-  id: user.get_blocked_users_list
+  id: user.get_all_blocked_users
 */
 /**
  * ```js
  * import { UserRepository } from '@amityco/ts-sdk'
- * const blockedUsers = await UserRepository.getBlockedUsersList()
- * // or with a limit on total results:
- * const blockedUsers = await UserRepository.getBlockedUsersList({ limit: 3 })
+ * const blockedUsers = await UserRepository.getAllBlockedUsers()
  * ```
  *
- * Fetches blocked {@link Amity.User} objects without requiring manual pagination.
- * Intended for UI interception to filter content from blocked users.
+ * Returns all blocked users as a non-paginated list (limit 100) with TTL-based caching (5-minute window).
+ * Within the TTL window, subsequent calls resolve instantly from the local store without any server call.
+ * After the TTL expires, the next call triggers a fresh server fetch.
  *
- * @param params Optional parameters
- * @param params.limit Maximum total number of blocked users to return (max: 100). Fetches all if not specified.
- * @returns Array of blocked {@link Amity.User} objects
+ * @returns A promise that resolves to an array of blocked {@link Amity.User} objects
  *
  * @category Block API
  * @async
  */
-const getBlockedUsersList = async (params) => {
-    const client = getActiveClient();
-    client.log('user/getBlockedUsersList');
-    const maxResults = (params === null || params === void 0 ? void 0 : params.limit) !== undefined ? Math.min(params.limit, BLOCK_LIST_DEFAULT_PAGE_LIMIT) : undefined;
-    const allUsers = [];
-    let token;
-    do {
-        const remaining = maxResults !== undefined ? maxResults - allUsers.length : BLOCK_LIST_DEFAULT_PAGE_LIMIT;
-        const options = token ? { token } : { limit: remaining };
-        // eslint-disable-next-line no-await-in-loop
-        const { data } = await client.http.get('/api/v4/me/user-blocks', { params: { options, isDeleted: false } });
-        const cachedAt = client.cache && Date.now();
-        const payload = prepareBlockedUserPayload(data);
-        if (client.cache) {
-            ingestInCache(payload, { cachedAt });
-        }
-        allUsers.push(...payload.users);
-        token = data.paging.next;
-    } while (token && (maxResults === undefined || allUsers.length < maxResults));
-    return allUsers.map(userLinkedObject);
+const getAllBlockedUsers = async () => {
+    const client = getActiveClient();
+    client.log('user/getAllBlockedUsers');
+    const engine = BlockedUserSyncEngine$1.getInstance();
+    // Ensure data is fetched (no-op if cache is fresh)
+    await engine.ensureFetched();
+    // Read from the engine's bounded ID list — O(blocked users) not O(cache size)
+    return engine.getCachedUsers();
 };
 /* end_public_function */
 
@@ -16424,7 +16542,7 @@ var index$q = /*#__PURE__*/Object.freeze({
     flagUser: flagUser,
     unflagUser: unflagUser,
     isUserFlaggedByMe: isUserFlaggedByMe,
-    getBlockedUsersList: getBlockedUsersList,
+    getAllBlockedUsers: getAllBlockedUsers,
     onUserUpdated: onUserUpdated,
     onUserDeleted: onUserDeleted$2,
     onUserFlagged: onUserFlagged,
@@ -18104,8 +18222,10 @@ const createLocalCommentEventSubscriber = (event, callback) => {
                     else {
                         const postCacheKey = ['post', 'get', comments[0].referenceId];
                         const postCache = (_d = pullFromCache(postCacheKey)) === null || _d === void 0 ? void 0 : _d.data;
-                        const updatedPost = Object.assign(Object.assign({}, postCache), { comments: postCache === null || postCache === void 0 ? void 0 : postCache.comments.filter(commentId => { var _a; return commentId !== ((_a = comments[0]) === null || _a === void 0 ? void 0 : _a.commentId); }) });
-                        pushToCache(postCacheKey, updatedPost);
+                        if (postCache) {
+                            const updatedPost = Object.assign(Object.assign({}, postCache), { comments: postCache === null || postCache === void 0 ? void 0 : postCache.comments.filter(commentId => { var _a; return commentId !== ((_a = comments[0]) === null || _a === void 0 ? void 0 : _a.commentId); }) });
+                            pushToCache(postCacheKey, updatedPost);
+                        }
                     }
                     const queries = (_e = queryCache(['comment', 'query'])) === null || _e === void 0 ? void 0 : _e.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
                     queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
@@ -23192,7 +23312,7 @@ const removeMembers = async (communityId, userIds) => {
  */
 class CommunityMembersPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, excludingRoles: _excludingRoles } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted", "excludingRoles"]);
         const options = token ? { token } : { limit };
         const isDeleted = includeDeleted === false ? false : undefined;
         const { data: queryResponse } = await this.http.get(`/api/v3/communities/${params.communityId}/users`, {
@@ -23841,7 +23961,7 @@ const getMembers = (params, callback, config) => {
  */
 class SearchCommunityMembersPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, excludingRoles } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted", "excludingRoles"]);
         const options = token ? { token } : { limit };
         const isDeleted = includeDeleted === false ? false : undefined;
         const { data: queryResponse } = await this.http.get(`/api/v3/communities/${params.communityId}/users`, {