@stream-io/feeds-client 0.2.1 → 0.2.3

package/dist/index.browser.cjs

@@ -415,6 +415,7 @@ decoders.Command = (input) => {
 decoders.CommentAddedEvent = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
+        activity: { type: 'ActivityResponse', isSingle: true },
         comment: { type: 'CommentResponse', isSingle: true },
         received_at: { type: 'DatetimeType', isSingle: true },
     };
@@ -431,6 +432,7 @@ decoders.CommentDeletedEvent = (input) => {
 decoders.CommentReactionAddedEvent = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
+        activity: { type: 'ActivityResponse', isSingle: true },
         comment: { type: 'CommentResponse', isSingle: true },
         reaction: { type: 'FeedsReactionResponse', isSingle: true },
         received_at: { type: 'DatetimeType', isSingle: true },
@@ -449,6 +451,7 @@ decoders.CommentReactionDeletedEvent = (input) => {
 decoders.CommentReactionUpdatedEvent = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
+        activity: { type: 'ActivityResponse', isSingle: true },
         comment: { type: 'CommentResponse', isSingle: true },
         reaction: { type: 'FeedsReactionResponse', isSingle: true },
         received_at: { type: 'DatetimeType', isSingle: true },
@@ -811,6 +814,7 @@ decoders.Message = (input) => {
         pin_expires: { type: 'DatetimeType', isSingle: true },
         pinned_at: { type: 'DatetimeType', isSingle: true },
         thread_participants: { type: 'User', isSingle: false },
+        member: { type: 'ChannelMember', isSingle: true },
         pinned_by: { type: 'User', isSingle: true },
         poll: { type: 'Poll', isSingle: true },
         quoted_message: { type: 'Message', isSingle: true },
@@ -864,6 +868,8 @@ decoders.ModerationCustomActionEvent = (input) => {
 };
 decoders.ModerationFlagResponse = (input) => {
     const typeMappings = {
+        created_at: { type: 'DatetimeType', isSingle: true },
+        updated_at: { type: 'DatetimeType', isSingle: true },
         review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
         user: { type: 'UserResponse', isSingle: true },
     };
@@ -1630,6 +1636,7 @@ class FeedsApi {
         const body = {
             type: request?.type,
             create_notification_activity: request?.create_notification_activity,
+            skip_push: request?.skip_push,
             custom: request?.custom,
         };
         const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/activities/{activity_id}/reactions', pathParams, undefined, body, 'application/json');
@@ -1776,6 +1783,7 @@ class FeedsApi {
             object_type: request?.object_type,
             create_notification_activity: request?.create_notification_activity,
             parent_id: request?.parent_id,
+            skip_push: request?.skip_push,
             attachments: request?.attachments,
             mentioned_user_ids: request?.mentioned_user_ids,
             custom: request?.custom,
@@ -1829,6 +1837,7 @@ class FeedsApi {
         };
         const body = {
             comment: request?.comment,
+            skip_push: request?.skip_push,
             custom: request?.custom,
         };
         const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/comments/{id}', pathParams, undefined, body, 'application/json');
@@ -1842,6 +1851,7 @@ class FeedsApi {
         const body = {
             type: request?.type,
             create_notification_activity: request?.create_notification_activity,
+            skip_push: request?.skip_push,
             custom: request?.custom,
         };
         const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/comments/{id}/reactions', pathParams, undefined, body, 'application/json');
@@ -2082,6 +2092,7 @@ class FeedsApi {
             create_notification_activity: request?.create_notification_activity,
             follower_role: request?.follower_role,
             push_preference: request?.push_preference,
+            skip_push: request?.skip_push,
             custom: request?.custom,
         };
         const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/follows', undefined, undefined, body, 'application/json');
@@ -2094,6 +2105,7 @@ class FeedsApi {
             target: request?.target,
             create_notification_activity: request?.create_notification_activity,
             push_preference: request?.push_preference,
+            skip_push: request?.skip_push,
             custom: request?.custom,
         };
         const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/follows', undefined, undefined, body, 'application/json');
@@ -4520,20 +4532,29 @@ function handleCommentAdded(event) {
 function handleCommentDeleted({ comment }) {
     const entityId = comment.parent_id ?? comment.object_id;
     this.state.next((currentState) => {
-        const newCommentsByEntityId = {
-            ...currentState.comments_by_entity_id,
-            [entityId]: {
-                ...currentState.comments_by_entity_id[entityId],
-            },
-        };
+        let newCommentsByEntityId;
         const index = this.getCommentIndex(comment, currentState);
-        if (newCommentsByEntityId?.[entityId]?.comments?.length && index !== -1) {
+        if (index !== -1) {
+            newCommentsByEntityId ?? (newCommentsByEntityId = {
+                ...currentState.comments_by_entity_id,
+                [entityId]: {
+                    ...currentState.comments_by_entity_id[entityId],
+                },
+            });
             newCommentsByEntityId[entityId].comments = [
                 ...newCommentsByEntityId[entityId].comments,
             ];
             newCommentsByEntityId[entityId]?.comments?.splice(index, 1);
         }
-        delete newCommentsByEntityId[comment.id];
+        if (typeof currentState.comments_by_entity_id[comment.id] !== 'undefined') {
+            newCommentsByEntityId ?? (newCommentsByEntityId = {
+                ...currentState.comments_by_entity_id,
+            });
+            delete newCommentsByEntityId[comment.id];
+        }
+        if (!newCommentsByEntityId) {
+            return currentState;
+        }
         return {
             ...currentState,
             comments_by_entity_id: newCommentsByEntityId,
@@ -4654,14 +4675,20 @@ function handleFeedMemberUpdated(event) {
 function handleFeedMemberRemoved(event) {
     const { connected_user: connectedUser } = this.client.state.getLatestValue();
     this.state.next((currentState) => {
-        const newState = {
-            ...currentState,
-            members: currentState.members?.filter((member) => member.user.id !== event.user?.id),
-        };
-        if (connectedUser?.id === event.member_id) {
+        let newState;
+        if (typeof currentState.members !== 'undefined') {
+            const filtered = currentState.members.filter((member) => member.user.id !== event.member_id);
+            if (filtered.length !== currentState.members.length) {
+                newState ?? (newState = { ...currentState });
+                newState.members = filtered;
+            }
+        }
+        if (connectedUser?.id === event.member_id &&
+            typeof currentState.own_membership !== 'undefined') {
+            newState ?? (newState = { ...currentState });
             delete newState.own_membership;
         }
-        return newState;
+        return newState ?? currentState;
     });
 }
 
@@ -4898,7 +4925,7 @@ const removePinnedActivityFromState = (activityResponse, pinnedActivities) => {
     if (index !== -1) {
         const newActivities = [...pinnedActivities];
         newActivities.splice(index, 1);
-        return { changed: true, activities: newActivities };
+        return { changed: true, pinned_activities: newActivities };
     }
     else {
         return { changed: false, pinned_activities: pinnedActivities };
@@ -5088,13 +5115,80 @@ function handleActivityReactionDeleted(event) {
     }
 }
 
+const updateNotificationStatusFromActivityMarked = (event, currentNotificationStatus, aggregatedActivities = []) => {
+    if (!currentNotificationStatus) {
+        return {
+            changed: false,
+        };
+    }
+    const newState = {
+        ...currentNotificationStatus,
+    };
+    if (event.mark_all_read) {
+        const allGroupIds = aggregatedActivities.map((activity) => activity.group);
+        newState.read_activities = [
+            ...new Set([
+                ...(currentNotificationStatus.read_activities ?? []),
+                ...allGroupIds,
+            ]),
+        ];
+    }
+    if (event.mark_read && event.mark_read.length > 0) {
+        newState.read_activities = [
+            ...new Set([
+                ...(currentNotificationStatus?.read_activities ?? []),
+                ...event.mark_read,
+            ]),
+        ];
+    }
+    if (event.mark_all_seen) {
+        newState.last_seen_at = new Date();
+    }
+    return {
+        changed: true,
+        data: { notification_status: newState },
+    };
+};
+function handleActivityMarked(event) {
+    const result = updateNotificationStatusFromActivityMarked(event, this.currentState.notification_status, this.currentState.aggregated_activities);
+    if (result.changed) {
+        this.state.partialNext({
+            notification_status: result.data?.notification_status,
+        });
+    }
+}
+
 function handleFeedUpdated(event) {
     this.state.partialNext({ ...event.feed });
 }
 
+const updateNotificationFeedFromEvent = (event) => {
+    const updates = {};
+    if (event.notification_status) {
+        updates.notification_status = event.notification_status;
+    }
+    if (event.aggregated_activities) {
+        updates.aggregated_activities = event.aggregated_activities;
+    }
+    // Only return changed if we have actual updates
+    if (Object.keys(updates).length > 0) {
+        return {
+            changed: true,
+            data: updates,
+        };
+    }
+    return {
+        changed: false,
+    };
+};
 function handleNotificationFeedUpdated(event) {
-    console.info('notification feed updated', event);
-    // TODO: handle notification feed updates
+    const result = updateNotificationFeedFromEvent(event);
+    if (result.changed) {
+        this.state.partialNext({
+            notification_status: result.data?.notification_status,
+            aggregated_activities: result.data?.aggregated_activities,
+        });
+    }
 }
 
 function handleWatchStarted() {
@@ -5149,7 +5243,7 @@ class Feed extends FeedApi {
             'feeds.poll.vote_removed': Feed.noop,
             'feeds.activity.pinned': Feed.noop,
             'feeds.activity.unpinned': Feed.noop,
-            'feeds.activity.marked': Feed.noop,
+            'feeds.activity.marked': handleActivityMarked.bind(this),
             'moderation.custom_action': Feed.noop,
             'moderation.flagged': Feed.noop,
             'moderation.mark_reviewed': Feed.noop,
@@ -6035,16 +6129,120 @@ const FeedOwnCapability = {
     UPDATE_FEED_MEMBERS: 'update-feed-members',
 };
 
+class SearchController {
+    constructor({ config, sources } = {}) {
+        this.addSource = (source) => {
+            this.state.partialNext({
+                sources: [...this.sources, source],
+            });
+        };
+        this.getSource = (sourceType) => this.sources.find((s) => s.type === sourceType);
+        this.removeSource = (sourceType) => {
+            const newSources = this.sources.filter((s) => s.type !== sourceType);
+            if (newSources.length === this.sources.length)
+                return;
+            this.state.partialNext({ sources: newSources });
+        };
+        this.activateSource = (sourceType) => {
+            const source = this.getSource(sourceType);
+            if (!source || source.isActive)
+                return;
+            if (this.config.keepSingleActiveSource) {
+                this.sources.forEach((s) => {
+                    if (s.type !== sourceType) {
+                        s.deactivate();
+                    }
+                });
+            }
+            source.activate();
+            this.state.partialNext({ sources: [...this.sources] });
+        };
+        this.deactivateSource = (sourceType) => {
+            const source = this.getSource(sourceType);
+            if (!source?.isActive)
+                return;
+            if (this.activeSources.length === 1)
+                return;
+            source.deactivate();
+            this.state.partialNext({ sources: [...this.sources] });
+        };
+        this.activate = () => {
+            if (!this.activeSources.length) {
+                const sourcesToActivate = this.config.keepSingleActiveSource
+                    ? this.sources.slice(0, 1)
+                    : this.sources;
+                sourcesToActivate.forEach((s) => s.activate());
+            }
+            if (this.isActive)
+                return;
+            this.state.partialNext({ isActive: true });
+        };
+        this.search = async (searchQuery) => {
+            const searchedSources = this.activeSources;
+            this.state.partialNext({
+                searchQuery,
+            });
+            await Promise.all(searchedSources.map((source) => source.search(searchQuery)));
+        };
+        this.cancelSearchQueries = () => {
+            this.activeSources.forEach((s) => s.cancelScheduledQuery());
+        };
+        this.clear = () => {
+            this.cancelSearchQueries();
+            this.sources.forEach((source) => source.state.next({ ...source.initialState, isActive: source.isActive }));
+            this.state.next((current) => ({
+                ...current,
+                isActive: true,
+                queriesInProgress: [],
+                searchQuery: '',
+            }));
+        };
+        this.exit = () => {
+            this.cancelSearchQueries();
+            this.sources.forEach((source) => source.state.next({ ...source.initialState, isActive: source.isActive }));
+            this.state.next((current) => ({
+                ...current,
+                isActive: false,
+                queriesInProgress: [],
+                searchQuery: '',
+            }));
+        };
+        this.state = new StateStore({
+            isActive: false,
+            searchQuery: '',
+            sources: sources ?? [],
+        });
+        this._internalState = new StateStore({});
+        this.config = { keepSingleActiveSource: true, ...config };
+    }
+    get hasNext() {
+        return this.sources.some((source) => source.hasNext);
+    }
+    get sources() {
+        return this.state.getLatestValue().sources;
+    }
+    get activeSources() {
+        return this.state.getLatestValue().sources.filter((s) => s.isActive);
+    }
+    get isActive() {
+        return this.state.getLatestValue().isActive;
+    }
+    get searchQuery() {
+        return this.state.getLatestValue().searchQuery;
+    }
+    get searchSourceTypes() {
+        return this.sources.map((s) => s.type);
+    }
+}
+
 const DEFAULT_SEARCH_SOURCE_OPTIONS = {
     debounceMs: 300,
     pageSize: 10,
     allowEmptySearchString: false,
+    resetOnNewSearchQuery: true,
 };
-class BaseSearchSource {
+class BaseSearchSourceBase {
     constructor(options) {
-        this.setDebounceOptions = ({ debounceMs }) => {
-            this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-        };
         this.activate = () => {
             if (this.isActive)
                 return;
@@ -6063,15 +6261,11 @@ class BaseSearchSource {
                 (this.hasNext || hasNewSearchQuery) &&
                 (this.allowEmptySearchString || searchString));
         };
-        this.search = (searchQuery) => this.searchDebounced(searchQuery);
-        const { debounceMs, pageSize, allowEmptySearchString } = {
-            ...DEFAULT_SEARCH_SOURCE_OPTIONS,
-            ...options,
-        };
+        const { pageSize, allowEmptySearchString, resetOnNewSearchQuery } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
         this.pageSize = pageSize;
         this.allowEmptySearchString = allowEmptySearchString;
+        this.resetOnNewSearchQuery = resetOnNewSearchQuery;
         this.state = new StateStore(this.initialState);
-        this.setDebounceOptions({ debounceMs });
     }
     get lastQueryError() {
         return this.state.getLatestValue().lastQueryError;
@@ -6113,10 +6307,14 @@ class BaseSearchSource {
         return this.state.getLatestValue().searchQuery;
     }
     getStateBeforeFirstQuery(newSearchString) {
+        const initialState = this.initialState;
+        const oldItems = this.items;
+        const items = this.resetOnNewSearchQuery ? initialState.items : oldItems;
         return {
             ...this.initialState,
+            items,
             isActive: this.isActive,
-            isLoading: true,
+            isLoading: this.resetOnNewSearchQuery ? true : !oldItems,
             searchQuery: newSearchString,
         };
     }
@@ -6129,12 +6327,10 @@ class BaseSearchSource {
             isLoading: false,
             items: isFirstPage
                 ? stateUpdate.items
-                : [...(this.items ?? []), ...(stateUpdate.items ?? [])],
+                : [...(this.items ?? []), ...(stateUpdate.items || [])],
         };
     }
-    async executeQuery(newSearchString) {
-        if (!this.canExecuteQuery(newSearchString))
-            return;
+    prepareStateForQuery(newSearchString) {
         const hasNewSearchQuery = typeof newSearchString !== 'undefined';
         const searchString = newSearchString ?? this.searchQuery;
         if (hasNewSearchQuery) {
@@ -6143,20 +6339,50 @@ class BaseSearchSource {
         else {
             this.state.partialNext({ isLoading: true });
         }
+        return { searchString, hasNewSearchQuery };
+    }
+    updatePaginationStateFromQuery(result) {
+        const { items, next } = result;
         const stateUpdate = {};
+        if (next || next === null) {
+            stateUpdate.next = next;
+            stateUpdate.hasNext = !!next;
+        }
+        else {
+            stateUpdate.offset = (this.offset ?? 0) + items.length;
+            stateUpdate.hasNext = items.length === this.pageSize;
+        }
+        return stateUpdate;
+    }
+    resetState() {
+        this.state.next(this.initialState);
+    }
+    resetStateAndActivate() {
+        this.resetState();
+        this.activate();
+    }
+}
+class BaseSearchSource extends BaseSearchSourceBase {
+    constructor(options) {
+        const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
+        super(options);
+        this.setDebounceOptions = ({ debounceMs }) => {
+            this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
+        };
+        this.search = (searchQuery) => this.searchDebounced(searchQuery);
+        this.setDebounceOptions({ debounceMs });
+    }
+    async executeQuery(newSearchString) {
+        if (!this.canExecuteQuery(newSearchString))
+            return;
+        const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
+        let stateUpdate = {};
         try {
             const results = await this.query(searchString);
             if (!results)
                 return;
-            const { items, next } = results;
-            if (typeof next === 'string' || next === null) {
-                stateUpdate.next = next;
-                stateUpdate.hasNext = !!next;
-            }
-            else {
-                stateUpdate.offset = (this.offset ?? 0) + items.length;
-                stateUpdate.hasNext = items.length === this.pageSize;
-            }
+            const { items } = results;
+            stateUpdate = this.updatePaginationStateFromQuery(results);
             stateUpdate.items = await this.filterQueryResults(items);
         }
         catch (e) {
@@ -6169,118 +6395,39 @@ class BaseSearchSource {
     cancelScheduledQuery() {
         this.searchDebounced.cancel();
     }
-    resetState() {
-        this.state.next(this.initialState);
-    }
-    resetStateAndActivate() {
-        this.resetState();
-        this.activate();
-    }
 }
-
-class SearchController {
-    constructor({ config, sources } = {}) {
-        this.addSource = (source) => {
-            this.state.partialNext({
-                sources: [...this.sources, source],
-            });
-        };
-        this.getSource = (sourceType) => this.sources.find((s) => s.type === sourceType);
-        this.removeSource = (sourceType) => {
-            const newSources = this.sources.filter((s) => s.type !== sourceType);
-            if (newSources.length === this.sources.length)
-                return;
-            this.state.partialNext({ sources: newSources });
-        };
-        this.activateSource = (sourceType) => {
-            const source = this.getSource(sourceType);
-            if (!source || source.isActive)
-                return;
-            if (this.config.keepSingleActiveSource) {
-                this.sources.forEach((s) => {
-                    if (s.type !== sourceType) {
-                        s.deactivate();
-                    }
-                });
-            }
-            source.activate();
-            this.state.partialNext({ sources: [...this.sources] });
-        };
-        this.deactivateSource = (sourceType) => {
-            const source = this.getSource(sourceType);
-            if (!source?.isActive)
-                return;
-            if (this.activeSources.length === 1)
-                return;
-            source.deactivate();
-            this.state.partialNext({ sources: [...this.sources] });
-        };
-        this.activate = () => {
-            if (!this.activeSources.length) {
-                const sourcesToActivate = this.config.keepSingleActiveSource
-                    ? this.sources.slice(0, 1)
-                    : this.sources;
-                sourcesToActivate.forEach((s) => s.activate());
-            }
-            if (this.isActive)
-                return;
-            this.state.partialNext({ isActive: true });
-        };
-        this.search = async (searchQuery) => {
-            const searchedSources = this.activeSources;
-            this.state.partialNext({
-                searchQuery,
-            });
-            await Promise.all(searchedSources.map((source) => source.search(searchQuery)));
-        };
-        this.cancelSearchQueries = () => {
-            this.activeSources.forEach((s) => s.cancelScheduledQuery());
-        };
-        this.clear = () => {
-            this.cancelSearchQueries();
-            this.sources.forEach((source) => source.state.next({ ...source.initialState, isActive: source.isActive }));
-            this.state.next((current) => ({
-                ...current,
-                isActive: true,
-                queriesInProgress: [],
-                searchQuery: '',
-            }));
-        };
-        this.exit = () => {
-            this.cancelSearchQueries();
-            this.sources.forEach((source) => source.state.next({ ...source.initialState, isActive: source.isActive }));
-            this.state.next((current) => ({
-                ...current,
-                isActive: false,
-                queriesInProgress: [],
-                searchQuery: '',
-            }));
+class BaseSearchSourceSync extends BaseSearchSourceBase {
+    constructor(options) {
+        const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
+        super(options);
+        this.setDebounceOptions = ({ debounceMs }) => {
+            this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
         };
-        this.state = new StateStore({
-            isActive: false,
-            searchQuery: '',
-            sources: sources ?? [],
-        });
-        this._internalState = new StateStore({});
-        this.config = { keepSingleActiveSource: true, ...config };
-    }
-    get hasNext() {
-        return this.sources.some((source) => source.hasNext);
-    }
-    get sources() {
-        return this.state.getLatestValue().sources;
-    }
-    get activeSources() {
-        return this.state.getLatestValue().sources.filter((s) => s.isActive);
-    }
-    get isActive() {
-        return this.state.getLatestValue().isActive;
+        this.search = (searchQuery) => this.searchDebounced(searchQuery);
+        this.setDebounceOptions({ debounceMs });
     }
-    get searchQuery() {
-        return this.state.getLatestValue().searchQuery;
+    executeQuery(newSearchString) {
+        if (!this.canExecuteQuery(newSearchString))
+            return;
+        const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
+        let stateUpdate = {};
+        try {
+            const results = this.query(searchString);
+            if (!results)
+                return;
+            const { items } = results;
+            stateUpdate = this.updatePaginationStateFromQuery(results);
+            stateUpdate.items = this.filterQueryResults(items);
+        }
+        catch (e) {
+            stateUpdate.lastQueryError = e;
+        }
+        finally {
+            this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+        }
     }
-    get searchSourceTypes() {
-        return this.sources.map((s) => s.type);
+    cancelScheduledQuery() {
+        this.searchDebounced.cancel();
     }
 }
 
@@ -6309,36 +6456,6 @@ class ActivitySearchSource extends BaseSearchSource {
     }
 }
 
-class UserSearchSource extends BaseSearchSource {
-    constructor(client, options) {
-        super(options);
-        this.type = 'user';
-        this.client = client;
-    }
-    async query(searchQuery) {
-        const { connected_user: connectedUser } = this.client.state.getLatestValue();
-        if (!connectedUser)
-            return { items: [] };
-        const { users: items } = await this.client.queryUsers({
-            payload: {
-                filter_conditions: {
-                    ...(!this.allowEmptySearchString || searchQuery.length > 0
-                        ? {
-                            name: {
-                                $autocomplete: searchQuery,
-                            },
-                        }
-                        : {}),
-                },
-            },
-        });
-        return { items, next: undefined };
-    }
-    filterQueryResults(items) {
-        return items;
-    }
-}
-
 class FeedSearchSource extends BaseSearchSource {
     constructor(client, options) {
         super(options);
@@ -6372,8 +6489,39 @@ class FeedSearchSource extends BaseSearchSource {
     }
 }
 
+class UserSearchSource extends BaseSearchSource {
+    constructor(client, options) {
+        super(options);
+        this.type = 'user';
+        this.client = client;
+    }
+    async query(searchQuery) {
+        const { connected_user: connectedUser } = this.client.state.getLatestValue();
+        if (!connectedUser)
+            return { items: [] };
+        const { users: items } = await this.client.queryUsers({
+            payload: {
+                filter_conditions: {
+                    ...(!this.allowEmptySearchString || searchQuery.length > 0
+                        ? {
+                            name: {
+                                $autocomplete: searchQuery,
+                            },
+                        }
+                        : {}),
+                },
+            },
+        });
+        return { items, next: undefined };
+    }
+    filterQueryResults(items) {
+        return items;
+    }
+}
+
 exports.ActivitySearchSource = ActivitySearchSource;
 exports.BaseSearchSource = BaseSearchSource;
+exports.BaseSearchSourceSync = BaseSearchSourceSync;
 exports.ChannelOwnCapability = ChannelOwnCapability;
 exports.Constants = Constants;
 exports.Feed = Feed;