@stream-io/feeds-client 0.1.10 → 0.2.0

package/src/gen-imports.ts

@@ -1,3 +1,3 @@
 export type { ApiClient } from './common/ApiClient';
 export type { StreamResponse } from './common/types';
-export { FeedsClient as FeedsApi } from './FeedsClient';
+export { FeedsClient as FeedsApi } from './feeds-client';

package/src/test-utils/index.ts

@@ -0,0 +1 @@
+export * from './response-generators';

package/src/test-utils/response-generators.ts

@@ -0,0 +1,101 @@
+import {
+  FeedResponse,
+  FollowResponse,
+  OwnUser,
+  OwnUserResponse,
+  UserResponse,
+} from '../gen/models';
+import { humanId } from 'human-id';
+
+export const getHumanId = () => humanId({ capitalize: false, separator: '-' });
+
+export const generateUserResponse = (
+  overrides: Partial<UserResponse> = {},
+): UserResponse => ({
+  id: `user-${getHumanId()}`,
+  name: humanId({ separator: ' ' }),
+  created_at: new Date(),
+  updated_at: new Date(),
+  banned: false,
+  language: 'en',
+  online: false,
+  role: 'user',
+  blocked_user_ids: [],
+  teams: [],
+  custom: {},
+  ...overrides,
+});
+
+export const generateOwnUserResponse = (
+  overrides: Partial<OwnUserResponse> = {},
+): OwnUserResponse => ({
+  ...generateUserResponse({
+    id: `own-user-${getHumanId()}`,
+  }),
+  invisible: false,
+  total_unread_count: 0,
+  unread_channels: 0,
+  unread_count: 0,
+  unread_threads: 0,
+  channel_mutes: [],
+  devices: [],
+  mutes: [],
+  ...overrides,
+});
+
+export const generateOwnUser = (overrides: Partial<OwnUser> = {}): OwnUser => ({
+  ...generateOwnUserResponse(),
+  devices: [],
+  mutes: [],
+  total_unread_count_by_team: {},
+  ...overrides,
+});
+
+export const generateFeedResponse = (
+  overrides: Omit<Partial<FeedResponse>, 'created_by' | 'fid'> & {
+    created_by?: Partial<UserResponse>;
+  } = {},
+): FeedResponse => {
+  const id = overrides.id || `feed-${getHumanId()}`;
+  const groupId = overrides.group_id || 'user';
+  const feed = `${groupId}:${id}`;
+
+  return {
+    id,
+    group_id: groupId,
+    created_at: new Date(),
+    updated_at: new Date(),
+    description: humanId({
+      addAdverb: true,
+      adjectiveCount: 4,
+      separator: ' ',
+    }),
+    follower_count: 0,
+    following_count: 0,
+    member_count: 0,
+    name: humanId({ separator: ' ' }),
+    pin_count: 0,
+    custom: {},
+    ...overrides,
+    feed,
+    created_by: generateUserResponse(overrides.created_by),
+  };
+};
+
+export const generateFollowResponse = (
+  overrides: Partial<FollowResponse> = {},
+): FollowResponse => {
+  const sourceFeedResponse = generateFeedResponse();
+  const targetFeedResponse = generateFeedResponse();
+
+  return {
+    created_at: new Date(),
+    updated_at: new Date(),
+    follower_role: 'user',
+    push_preference: 'all',
+    status: 'accepted',
+    source_feed: sourceFeedResponse,
+    target_feed: targetFeedResponse,
+    ...overrides,
+  };
+};

package/src/types-internal.ts

@@ -1,5 +1,16 @@
+import { WSEvent } from './gen/models';
+
 export type UpdateStateResult<T> = T & {
   changed: boolean;
 };
 
 export type FromArray<T> = T extends Array<infer L> ? L : never;
+
+export type EventPayload<T extends WSEvent['type']> = Extract<
+  WSEvent,
+  { type: T }
+>;
+
+export type PartializeAllBut<T, K extends keyof T> = Pick<T, K> & {
+  [key in K]?: T[key];
+};

package/src/types.ts

@@ -8,7 +8,7 @@ import type {
   ActivityResponse,
   CommentResponse,
 } from './gen/models';
-import { FeedsClient } from './FeedsClient';
+import { FeedsClient } from './feeds-client';
 
 export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent;
 export type ActivityIdOrCommentId = string;

package/src/utils/check-has-another-page.ts

@@ -0,0 +1,6 @@
+export const checkHasAnotherPage = <T extends unknown | undefined>(
+  v: T,
+  cursor: string | undefined,
+) =>
+  (typeof v === 'undefined' && typeof cursor === 'undefined') ||
+  typeof cursor === 'string';

package/src/utils/constants.ts

@@ -0,0 +1,3 @@
+export const Constants = {
+  DEFAULT_COMMENT_PAGINATION: 'first',
+} as const;

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './check-has-another-page';
+export * from './unique-array-merge';
+export * from './constants';
+export * from './type-assertions';
+export * from './state-update-queue';

package/src/{state-updates → utils}/state-update-queue.test.ts

@@ -6,7 +6,7 @@ describe('state-update-queue', () => {
   describe('shouldUpdateState', () => {
     it('should return true when watch is false', () => {
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue: new Set(['other-id']),
         watch: false,
       });
@@ -14,11 +14,11 @@ describe('state-update-queue', () => {
       expect(result).toBe(true);
     });
 
-    it('should return true when watch is true but stateUpdateId is not in queue', () => {
+    it('should return true when watch is true but queueId is not in queue', () => {
       const stateUpdateQueue = new Set(['other-id-1', 'other-id-2']);
 
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue: stateUpdateQueue,
         watch: true,
       });
@@ -27,11 +27,11 @@ describe('state-update-queue', () => {
       expect(result).toBe(true);
     });
 
-    it('should return false and remove stateUpdateId from queue when watch is true and stateUpdateId is in queue', () => {
+    it('should return false and remove queueId from queue when watch is true and queueId is in queue', () => {
       const stateUpdateQueue = new Set(['test-id', 'other-id']);
 
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue,
         watch: true,
       });
@@ -42,7 +42,7 @@ describe('state-update-queue', () => {
 
     it('should handle empty queue when watch is true', () => {
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue: new Set(),
         watch: true,
       });

package/src/utils/state-update-queue.ts

@@ -0,0 +1,42 @@
+import { isFollowResponse } from './type-assertions';
+
+export const shouldUpdateState = ({
+  stateUpdateQueueId,
+  stateUpdateQueue,
+  watch,
+}: {
+  stateUpdateQueueId: string;
+  stateUpdateQueue: Set<string>;
+  watch: boolean;
+}) => {
+  if (!watch) {
+    return true;
+  }
+
+  if (watch && stateUpdateQueue.has(stateUpdateQueueId)) {
+    stateUpdateQueue.delete(stateUpdateQueueId);
+    return false;
+  }
+
+  stateUpdateQueue.add(stateUpdateQueueId);
+  return true;
+};
+
+export function getStateUpdateQueueId(
+  data: object,
+  prefix?: 'deleted' | 'updated' | 'created' | (string & {}),
+) {
+  if (isFollowResponse(data)) {
+    const toJoin = [data.source_feed.feed, data.target_feed.feed];
+    if (prefix) {
+      toJoin.unshift(prefix);
+    }
+    return toJoin.join('-');
+  }
+  // else if (isMemberResponse(data)) {
+  // }
+
+  throw new Error(
+    `Cannot create state update queueId for data: ${JSON.stringify(data)}`,
+  );
+}

package/src/utils/type-assertions.ts

@@ -0,0 +1,22 @@
+import { CommentResponse, FollowResponse } from '../gen/models';
+import { StreamFile } from '../types';
+import { CommentParent } from '../types';
+
+export const isFollowResponse = (data: object): data is FollowResponse => {
+  return 'source_feed' in data && 'target_feed' in data;
+};
+
+export const isCommentResponse = (
+  entity: CommentParent,
+): entity is CommentResponse => {
+  return typeof (entity as CommentResponse)?.object_id === 'string';
+};
+
+export const isImageFile = (file: StreamFile) => {
+  // photoshop files begin with 'image/'
+  return file.type.startsWith('image/') && !file.type.endsWith('.photoshop');
+};
+
+export const isVideoFile = (file: StreamFile) => {
+  return file.type.startsWith('video/');
+};

package/src/{utils.test.ts → utils/unique-array-merge.test.ts}

@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest';
 
-import { uniqueArrayMerge } from './utils';
+import { uniqueArrayMerge } from './unique-array-merge';
 
 describe('utils', () => {
-  describe('uniqueMerge', () => {
+  describe(uniqueArrayMerge.name, () => {
     it('should merge arrays with unique objects based on key', () => {
       const existingArray = [
         { id: '1', name: 'Alice' },
@@ -123,7 +123,11 @@ describe('utils', () => {
         email: string;
       }) => item.email;
 
-      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKeyByEmail);
+      const result = uniqueArrayMerge(
+        existingArray,
+        arrayToMerge,
+        getKeyByEmail,
+      );
 
       expect(result).toEqual([
         { id: '1', name: 'Alice', email: 'alice@example.com' },

package/src/utils/unique-array-merge.ts

@@ -0,0 +1,19 @@
+export const uniqueArrayMerge = <T>(
+  existingArray: T[],
+  arrayToMerge: T[],
+  getKey: (v: T) => string,
+) => {
+  const existing = new Set<string>();
+
+  existingArray.forEach((value) => {
+    const key = getKey(value);
+    existing.add(key);
+  });
+
+  const filteredArrayToMerge = arrayToMerge.filter((value) => {
+    const key = getKey(value);
+    return !existing.has(key);
+  });
+
+  return existingArray.concat(filteredArrayToMerge);
+};

package/dist/src/FeedsClient.d.ts

@@ -1,75 +0,0 @@
-import { FeedsApi } from './gen/feeds/FeedsApi';
-import { ActivityResponse, FileUploadRequest, FollowBatchRequest, ImageUploadRequest, OwnUser, PollResponse, PollVotesResponse, QueryFeedsRequest, QueryPollVotesRequest, SingleFollowRequest, UserRequest } from './gen/models';
-import { FeedsEvent, StreamFile, TokenOrProvider } from './types';
-import { StateStore } from './common/StateStore';
-import { Feed } from './Feed';
-import { FeedsClientOptions, StreamResponse } from './common/types';
-import { ModerationClient } from './ModerationClient';
-import { StreamPoll } from './common/Poll';
-export type FeedsClientState = {
-    connected_user: OwnUser | undefined;
-    is_ws_connection_healthy: boolean;
-};
-export declare class FeedsClient extends FeedsApi {
-    readonly state: StateStore<FeedsClientState>;
-    readonly moderation: ModerationClient;
-    private readonly tokenManager;
-    private wsConnection?;
-    private readonly connectionIdManager;
-    private readonly eventDispatcher;
-    private readonly polls_by_id;
-    private activeFeeds;
-    private healthyConnectionChangedEventCount;
-    constructor(apiKey: string, options?: FeedsClientOptions);
-    pollFromState: (id: string) => StreamPoll | undefined;
-    hydratePollCache(activities: ActivityResponse[]): void;
-    connectUser: (user: UserRequest, tokenProvider: TokenOrProvider) => Promise<void>;
-    devToken: (userId: string) => string;
-    closePoll: (request: {
-        poll_id: string;
-    }) => Promise<StreamResponse<PollResponse>>;
-    uploadFile: (request: Omit<FileUploadRequest, "file"> & {
-        file: StreamFile;
-    }) => Promise<StreamResponse<import("./gen/models").FileUploadResponse>>;
-    uploadImage: (request: Omit<ImageUploadRequest, "file"> & {
-        file: StreamFile;
-    }) => Promise<StreamResponse<import("./gen/models").ImageUploadResponse>>;
-    queryPollAnswers: (request: QueryPollVotesRequest & {
-        poll_id: string;
-        user_id?: string;
-    }) => Promise<StreamResponse<PollVotesResponse>>;
-    queryPollOptionVotes: (request: QueryPollVotesRequest & {
-        filter: QueryPollVotesRequest["filter"] & {
-            option_id: string;
-        };
-        poll_id: string;
-        user_id?: string;
-    }) => Promise<StreamResponse<PollVotesResponse>>;
-    disconnectUser: () => Promise<void>;
-    on: (eventName: "all" | "app.updated" | "feeds.activity.added" | "feeds.activity.deleted" | "feeds.activity.marked" | "feeds.activity.pinned" | "feeds.activity.reaction.added" | "feeds.activity.reaction.deleted" | "feeds.activity.reaction.updated" | "feeds.activity.removed_from_feed" | "feeds.activity.unpinned" | "feeds.activity.updated" | "feeds.bookmark.added" | "feeds.bookmark.deleted" | "feeds.bookmark.updated" | "feeds.bookmark_folder.deleted" | "feeds.bookmark_folder.updated" | "feeds.comment.added" | "feeds.comment.deleted" | "feeds.comment.reaction.added" | "feeds.comment.reaction.deleted" | "feeds.comment.reaction.updated" | "feeds.comment.updated" | "feeds.feed.created" | "feeds.feed.deleted" | "feeds.feed.updated" | "feeds.feed_group.changed" | "feeds.feed_group.deleted" | "feeds.feed_member.added" | "feeds.feed_member.removed" | "feeds.feed_member.updated" | "feeds.follow.created" | "feeds.follow.deleted" | "feeds.follow.updated" | "feeds.notification_feed.updated" | "feeds.poll.closed" | "feeds.poll.deleted" | "feeds.poll.updated" | "feeds.poll.vote_casted" | "feeds.poll.vote_changed" | "feeds.poll.vote_removed" | "health.check" | "user.updated" | "moderation.custom_action" | "moderation.flagged" | "moderation.mark_reviewed" | "user.banned" | "user.deactivated" | "user.muted" | "user.reactivated" | "connection.changed" | "network.changed", handler: (event: FeedsEvent & {
-        fid?: string;
-    }) => void) => () => void;
-    off: (eventName: "all" | "app.updated" | "feeds.activity.added" | "feeds.activity.deleted" | "feeds.activity.marked" | "feeds.activity.pinned" | "feeds.activity.reaction.added" | "feeds.activity.reaction.deleted" | "feeds.activity.reaction.updated" | "feeds.activity.removed_from_feed" | "feeds.activity.unpinned" | "feeds.activity.updated" | "feeds.bookmark.added" | "feeds.bookmark.deleted" | "feeds.bookmark.updated" | "feeds.bookmark_folder.deleted" | "feeds.bookmark_folder.updated" | "feeds.comment.added" | "feeds.comment.deleted" | "feeds.comment.reaction.added" | "feeds.comment.reaction.deleted" | "feeds.comment.reaction.updated" | "feeds.comment.updated" | "feeds.feed.created" | "feeds.feed.deleted" | "feeds.feed.updated" | "feeds.feed_group.changed" | "feeds.feed_group.deleted" | "feeds.feed_member.added" | "feeds.feed_member.removed" | "feeds.feed_member.updated" | "feeds.follow.created" | "feeds.follow.deleted" | "feeds.follow.updated" | "feeds.notification_feed.updated" | "feeds.poll.closed" | "feeds.poll.deleted" | "feeds.poll.updated" | "feeds.poll.vote_casted" | "feeds.poll.vote_changed" | "feeds.poll.vote_removed" | "health.check" | "user.updated" | "moderation.custom_action" | "moderation.flagged" | "moderation.mark_reviewed" | "user.banned" | "user.deactivated" | "user.muted" | "user.reactivated" | "connection.changed" | "network.changed", handler: (event: FeedsEvent & {
-        fid?: string;
-    }) => void) => void;
-    feed: (groupId: string, id: string) => Feed;
-    queryFeeds(request?: QueryFeedsRequest): Promise<{
-        feeds: Feed[];
-        next: string | undefined;
-        prev: string | undefined;
-        metadata: import("./common/types").RequestMetadata;
-        duration: string;
-    }>;
-    updateNetworkConnectionStatus: (event: {
-        type: "online" | "offline";
-    } | Event) => void;
-    follow(request: SingleFollowRequest): Promise<StreamResponse<import("./gen/models").SingleFollowResponse>>;
-    followBatch(request: FollowBatchRequest): Promise<StreamResponse<import("./gen/models").FollowBatchResponse>>;
-    unfollow(request: SingleFollowRequest): Promise<StreamResponse<import("./gen/models").UnfollowResponse>>;
-    stopWatchingFeed(request: {
-        feed_group_id: string;
-        feed_id: string;
-    }): Promise<StreamResponse<import("./gen/models").Response>>;
-    private readonly getOrCreateActiveFeed;
-    private findActiveFeedByActivityId;
-}

package/dist/src/state-updates/activity-reaction-utils.d.ts

@@ -1,10 +0,0 @@
-import { ActivityReactionAddedEvent, ActivityReactionDeletedEvent, ActivityResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const addReactionToActivity: (event: ActivityReactionAddedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const removeReactionFromActivity: (event: ActivityReactionDeletedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const addReactionToActivities: (event: ActivityReactionAddedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const removeReactionFromActivities: (event: ActivityReactionDeletedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;

package/dist/src/state-updates/activity-utils.d.ts

@@ -1,13 +0,0 @@
-import { ActivityResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const addActivitiesToState: (newActivities: ActivityResponse[], activities: ActivityResponse[] | undefined, position: "start" | "end") => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const updateActivityInState: (updatedActivityResponse: ActivityResponse, activities: ActivityResponse[]) => {
-    changed: boolean;
-    activities: ActivityResponse[];
-};
-export declare const removeActivityFromState: (activityResponse: ActivityResponse, activities: ActivityResponse[]) => {
-    changed: boolean;
-    activities: ActivityResponse[];
-};

package/dist/src/state-updates/bookmark-utils.d.ts

@@ -1,14 +0,0 @@
-import { BookmarkAddedEvent, BookmarkDeletedEvent, BookmarkUpdatedEvent, ActivityResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const addBookmarkToActivity: (event: BookmarkAddedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const removeBookmarkFromActivity: (event: BookmarkDeletedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const updateBookmarkInActivity: (event: BookmarkUpdatedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const addBookmarkToActivities: (event: BookmarkAddedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const removeBookmarkFromActivities: (event: BookmarkDeletedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const updateBookmarkInActivities: (event: BookmarkUpdatedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;

package/dist/src/state-updates/follow-utils.d.ts

@@ -1,19 +0,0 @@
-import { FeedState } from '../Feed';
-import { FollowResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const handleFollowCreated: (follow: FollowResponse, currentState: FeedState, currentFeedId: string, connectedUserId?: string) => UpdateStateResult<{
-    data: FeedState;
-}>;
-export declare const handleFollowDeleted: (follow: FollowResponse | {
-    source_feed: {
-        fid: string;
-    };
-    target_feed: {
-        fid: string;
-    };
-}, currentState: FeedState, currentFeedId: string, connectedUserId?: string) => UpdateStateResult<{
-    data: FeedState;
-}>;
-export declare const handleFollowUpdated: (currentState: FeedState) => UpdateStateResult<{
-    data: FeedState;
-}>;

package/dist/src/state-updates/state-update-queue.d.ts

@@ -1,15 +0,0 @@
-import { FollowResponse } from '../gen/models';
-export declare const shouldUpdateState: ({ stateUpdateId, stateUpdateQueue, watch, }: {
-    stateUpdateId: string;
-    stateUpdateQueue: Set<string>;
-    watch: boolean;
-}) => boolean;
-export declare const getStateUpdateQueueIdForFollow: (follow: FollowResponse) => string;
-export declare const getStateUpdateQueueIdForUnfollow: (follow: FollowResponse | {
-    source_feed: {
-        fid: string;
-    };
-    target_feed: {
-        fid: string;
-    };
-}) => string;

package/dist/src/utils.d.ts

@@ -1,10 +0,0 @@
-import { CommentParent, StreamFile } from './types';
-import type { CommentResponse } from './gen/models';
-export declare const isImageFile: (file: StreamFile) => boolean;
-export declare const isVideoFile: (file: StreamFile) => boolean;
-export declare const checkHasAnotherPage: <T extends unknown | undefined>(v: T, cursor: string | undefined) => boolean;
-export declare const isCommentResponse: (entity: CommentParent) => entity is CommentResponse;
-export declare const Constants: {
-    readonly DEFAULT_COMMENT_PAGINATION: "first";
-};
-export declare const uniqueArrayMerge: <T>(existingArray: T[], arrayToMerge: T[], getKey: (v: T) => string) => T[];

package/src/state-updates/activity-reaction-utils.ts

@@ -1,107 +0,0 @@
-import {
-  ActivityReactionAddedEvent,
-  ActivityReactionDeletedEvent,
-  ActivityResponse,
-} from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-
-const updateActivityInActivities = (
-  updatedActivity: ActivityResponse,
-  activities: ActivityResponse[],
-): UpdateStateResult<{ activities: ActivityResponse[] }> => {
-  const index = activities.findIndex((a) => a.id === updatedActivity.id);
-  if (index !== -1) {
-    const newActivities = [...activities];
-    newActivities[index] = updatedActivity;
-    return { changed: true, activities: newActivities };
-  } else {
-    return { changed: false, activities };
-  }
-};
-
-export const addReactionToActivity = (
-  event: ActivityReactionAddedEvent,
-  activity: ActivityResponse,
-  isCurrentUser: boolean,
-): UpdateStateResult<ActivityResponse> => {
-  // Update own_reactions if the reaction is from the current user
-  const ownReactions = [...(activity.own_reactions || [])];
-  if (isCurrentUser) {
-    ownReactions.push(event.reaction);
-  }
-
-  return {
-    ...activity,
-    own_reactions: ownReactions,
-    latest_reactions: event.activity.latest_reactions,
-    reaction_groups: event.activity.reaction_groups,
-    changed: true,
-  };
-};
-
-export const removeReactionFromActivity = (
-  event: ActivityReactionDeletedEvent,
-  activity: ActivityResponse,
-  isCurrentUser: boolean,
-): UpdateStateResult<ActivityResponse> => {
-  // Update own_reactions if the reaction is from the current user
-  const ownReactions = isCurrentUser
-    ? (activity.own_reactions || []).filter(
-        (r) =>
-          !(
-            r.type === event.reaction.type &&
-            r.user.id === event.reaction.user.id
-          ),
-      )
-    : activity.own_reactions;
-
-  return {
-    ...activity,
-    own_reactions: ownReactions,
-    latest_reactions: event.activity.latest_reactions,
-    reaction_groups: event.activity.reaction_groups,
-    changed: true,
-  };
-};
-
-export const addReactionToActivities = (
-  event: ActivityReactionAddedEvent,
-  activities: ActivityResponse[] | undefined,
-  isCurrentUser: boolean,
-): UpdateStateResult<{ activities: ActivityResponse[] }> => {
-  if (!activities) {
-    return { changed: false, activities: [] };
-  }
-
-  const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-  if (activityIndex === -1) {
-    return { changed: false, activities };
-  }
-
-  const activity = activities[activityIndex];
-  const updatedActivity = addReactionToActivity(event, activity, isCurrentUser);
-  return updateActivityInActivities(updatedActivity, activities);
-};
-
-export const removeReactionFromActivities = (
-  event: ActivityReactionDeletedEvent,
-  activities: ActivityResponse[] | undefined,
-  isCurrentUser: boolean,
-): UpdateStateResult<{ activities: ActivityResponse[] }> => {
-  if (!activities) {
-    return { changed: false, activities: [] };
-  }
-
-  const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-  if (activityIndex === -1) {
-    return { changed: false, activities };
-  }
-
-  const activity = activities[activityIndex];
-  const updatedActivity = removeReactionFromActivity(
-    event,
-    activity,
-    isCurrentUser,
-  );
-  return updateActivityInActivities(updatedActivity, activities);
-};