@stream-io/feeds-client 0.1.1 → 0.1.2

package/dist/index.node.cjs

@@ -261,6 +261,14 @@ decoders.BookmarkDeletedEvent = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.BookmarkFolderDeletedEvent = (input) => {
+    const typeMappings = {
+        created_at: { type: 'DatetimeType', isSingle: true },
+        bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+        received_at: { type: 'DatetimeType', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.BookmarkFolderResponse = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
@@ -268,6 +276,14 @@ decoders.BookmarkFolderResponse = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.BookmarkFolderUpdatedEvent = (input) => {
+    const typeMappings = {
+        created_at: { type: 'DatetimeType', isSingle: true },
+        bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+        received_at: { type: 'DatetimeType', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.BookmarkResponse = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
@@ -1227,6 +1243,12 @@ decoders.UpdateBlockListResponse = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.UpdateBookmarkFolderResponse = (input) => {
+    const typeMappings = {
+        bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.UpdateBookmarkResponse = (input) => {
     const typeMappings = {
         bookmark: { type: 'BookmarkResponse', isSingle: true },
@@ -1647,6 +1669,26 @@ class FeedsApi {
         decoders.QueryBookmarkFoldersResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
+    async deleteBookmarkFolder(request) {
+        const pathParams = {
+            folder_id: request?.folder_id,
+        };
+        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/bookmark_folders/{folder_id}', pathParams, undefined);
+        decoders.DeleteBookmarkFolderResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
+    async updateBookmarkFolder(request) {
+        const pathParams = {
+            folder_id: request?.folder_id,
+        };
+        const body = {
+            name: request?.name,
+            custom: request?.custom,
+        };
+        const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/bookmark_folders/{folder_id}', pathParams, undefined, body, 'application/json');
+        decoders.UpdateBookmarkFolderResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
     async queryBookmarks(request) {
         const body = {
             limit: request?.limit,
@@ -2323,14 +2365,9 @@ class StateStore {
             let previouslySelectedValues;
             const wrappedHandler = (nextValue) => {
                 const newlySelectedValues = selector(nextValue);
-                let hasUpdatedValues = typeof previouslySelectedValues === 'undefined';
-                for (const key in previouslySelectedValues) {
-                    if (previouslySelectedValues[key] === newlySelectedValues[key])
-                        continue;
-                    hasUpdatedValues = true;
-                    break;
-                }
-                if (!hasUpdatedValues)
+                // shallow comparison of previouslySelectedValues and newlySelectedValues
+                const selectionsAreEqual = StateStore.doSelectionsEqual(previouslySelectedValues, newlySelectedValues);
+                if (selectionsAreEqual)
                     return;
                 // save a copy of previouslySelectedValues before running
                 // handler - if previouslySelectedValues are set to
@@ -2361,7 +2398,7 @@ class StateStore {
             ? newValueOrPatch(this.value)
             : newValueOrPatch;
         // do not notify subscribers if the value hasn't changed
-        if (newValue === this.value)
+        if (Object.is(newValue, this.value))
             return;
         this.preprocessors.forEach((preprocessor) => preprocessor(newValue, this.value));
         const oldValue = this.value;
@@ -2378,6 +2415,19 @@ class StateStore {
             this.handlers.delete(handler);
         };
     }
+    static doSelectionsEqual(previouslySelectedValues, newlySelectedValues) {
+        let selectionsAreEqual;
+        if ((selectionsAreEqual = typeof previouslySelectedValues !== 'undefined')) {
+            for (const key in newlySelectedValues) {
+                if (Object.is(previouslySelectedValues[key], newlySelectedValues[key])) {
+                    continue;
+                }
+                selectionsAreEqual = false;
+                break;
+            }
+        }
+        return selectionsAreEqual;
+    }
     /**
      * Registers a preprocessor function that will be called before the state is updated.
      *
@@ -2603,7 +2653,7 @@ function getRandomValuesWithMathRandom(bytes) {
     }
 }
 const getRandomValues = (() => {
-    if (typeof crypto?.getRandomValues !== 'undefined') {
+    if (typeof crypto !== 'undefined' && typeof crypto?.getRandomValues !== 'undefined') {
         return crypto.getRandomValues.bind(crypto);
     }
     else if (typeof msCrypto !== 'undefined') {
@@ -3612,6 +3662,8 @@ const eventDecoderMapping = {
     'feeds.bookmark.added': (data) => decoders.BookmarkAddedEvent(data),
     'feeds.bookmark.deleted': (data) => decoders.BookmarkDeletedEvent(data),
     'feeds.bookmark.updated': (data) => decoders.BookmarkUpdatedEvent(data),
+    'feeds.bookmark_folder.deleted': (data) => decoders.BookmarkFolderDeletedEvent(data),
+    'feeds.bookmark_folder.updated': (data) => decoders.BookmarkFolderUpdatedEvent(data),
     'feeds.comment.added': (data) => decoders.CommentAddedEvent(data),
     'feeds.comment.deleted': (data) => decoders.CommentDeletedEvent(data),
     'feeds.comment.reaction.added': (data) => decoders.CommentReactionAddedEvent(data),
@@ -4014,6 +4066,8 @@ class Feed extends FeedApi {
             'feeds.bookmark.added': this.handleBookmarkAdded.bind(this),
             'feeds.bookmark.deleted': this.handleBookmarkDeleted.bind(this),
             'feeds.bookmark.updated': this.handleBookmarkUpdated.bind(this),
+            'feeds.bookmark_folder.deleted': Feed.noop,
+            'feeds.bookmark_folder.updated': Feed.noop,
             'feeds.comment.added': (event) => {
                 const { comment } = event;
                 const forId = comment.parent_id ?? comment.object_id;
@@ -4103,16 +4157,19 @@ class Feed extends FeedApi {
                     return;
                 // this feed followed someone
                 if (event.follow.source_feed.fid === this.fid) {
-                    if (this.currentState.following_pagination?.next === END_OF_LIST) {
-                        this.state.next((currentState) => ({
+                    this.state.next((currentState) => {
+                        const newState = {
                             ...currentState,
                             ...event.follow.source_feed,
+                        };
+                        if (currentState.following_pagination?.next === END_OF_LIST) {
                             // TODO: respect sort
-                            following: currentState.following
+                            newState.following = currentState.following
                                 ? currentState.following.concat(event.follow)
-                                : [event.follow],
-                        }));
-                    }
+                                : [event.follow];
+                        }
+                        return newState;
+                    });
                 }
                 else if (
                 // someone followed this feed
@@ -4122,14 +4179,14 @@ class Feed extends FeedApi {
                     this.state.next((currentState) => {
                         const newState = { ...currentState, ...event.follow.target_feed };
                         if (source.created_by.id === connectedUser?.id) {
-                            newState.own_follows = newState.own_follows
-                                ? newState.own_follows.concat(event.follow)
+                            newState.own_follows = currentState.own_follows
+                                ? currentState.own_follows.concat(event.follow)
                                 : [event.follow];
                         }
                         if (currentState.followers_pagination?.next === END_OF_LIST) {
                             // TODO: respect sort
-                            newState.followers = newState.followers
-                                ? newState.followers.concat(event.follow)
+                            newState.followers = currentState.followers
+                                ? currentState.followers.concat(event.follow)
                                 : [event.follow];
                         }
                         return newState;
@@ -4155,9 +4212,9 @@ class Feed extends FeedApi {
                     this.state.next((currentState) => {
                         const newState = { ...currentState, ...event.follow.target_feed };
                         if (source.created_by.id === connectedUser?.id) {
-                            newState.own_follows = newState.own_follows?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
+                            newState.own_follows = currentState.own_follows?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
                         }
-                        newState.followers = newState.followers?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
+                        newState.followers = currentState.followers?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
                         return newState;
                     });
                 }
@@ -5065,7 +5122,10 @@ class FeedsClient extends FeedsApi {
                 }, this.tokenManager, this.connectionIdManager, [decodeWSEvent]);
                 this.wsConnection.on('all', (event) => this.eventDispatcher.dispatch(event));
                 const connectedEvent = await this.wsConnection.connect();
-                this.state.partialNext({ connectedUser: connectedEvent?.me });
+                this.state.partialNext({
+                    connectedUser: connectedEvent?.me,
+                    isWsConnectionHealthy: this.wsConnection.isHealthy,
+                });
             }
             catch (err) {
                 await this.disconnectUser();
@@ -5120,13 +5180,20 @@ class FeedsClient extends FeedsApi {
             removeConnectionEventListeners(this.updateNetworkConnectionStatus);
             this.connectionIdManager.reset();
             this.tokenManager.reset();
-            this.state.partialNext({ connectedUser: undefined });
+            this.state.partialNext({ connectedUser: undefined, isWsConnectionHealthy: false });
         };
         this.on = this.eventDispatcher.on;
         this.off = this.eventDispatcher.off;
         this.feed = (groupId, id) => {
             return this.getOrCreateActiveFeed(groupId, id);
         };
+        this.updateNetworkConnectionStatus = (event) => {
+            const networkEvent = {
+                type: 'network.changed',
+                online: event.type === 'online',
+            };
+            this.eventDispatcher.dispatch(networkEvent);
+        };
         this.getOrCreateActiveFeed = (group, id, data) => {
             const fid = `${group}:${id}`;
             if (this.activeFeeds[fid]) {
@@ -5138,15 +5205,9 @@ class FeedsClient extends FeedsApi {
                 return feed;
             }
         };
-        this.updateNetworkConnectionStatus = (event) => {
-            const networkEvent = {
-                type: 'network.changed',
-                online: event.type === 'online',
-            };
-            this.eventDispatcher.dispatch(networkEvent);
-        };
         this.state = new StateStore({
             connectedUser: undefined,
+            isWsConnectionHealthy: false,
         });
         this.moderation = new ModerationClient(apiClient);
         this.tokenManager = tokenManager;
@@ -5156,6 +5217,11 @@ class FeedsClient extends FeedsApi {
             const fid = event.fid;
             const feed = typeof fid === 'string' ? this.activeFeeds[fid] : undefined;
             switch (event.type) {
+                case 'connection.changed': {
+                    const { online } = event;
+                    this.state.partialNext({ isWsConnectionHealthy: online });
+                    break;
+                }
                 case 'feeds.feed.created': {
                     if (feed)
                         break;