@stream-io/feeds-client 0.2.6 → 0.2.8

package/package.json

@@ -1,48 +1,36 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "packageManager": "yarn@3.2.4",
-  "main": "./dist/index.node.js",
+  "main": "./dist/es/index.mjs",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/types/index.d.ts",
       "react-native": {
-        "import": "./dist/index.browser.js",
-        "require": "./dist/index.browser.cjs"
+        "import": "./dist/es/index.mjs",
+        "require": "./dist/cjs/index.js"
       },
-      "browser": {
-        "import": "./dist/index.browser.js",
-        "require": "./dist/index.browser.cjs"
-      },
-      "node": {
-        "import": "./dist/index.node.js",
-        "require": "./dist/index.node.cjs"
-      },
-      "default": "./dist/index.node.js"
+      "import": "./dist/es/index.mjs",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/es/index.mjs"
     },
     "./react-bindings": {
-      "types": "./dist/@react-bindings/index.d.ts",
+      "types": "./dist/types/bindings/react/index.d.ts",
       "react-native": {
-        "import": "./dist/index-react-bindings.browser.js",
-        "require": "./dist/index-react-bindings.browser.cjs"
-      },
-      "browser": {
-        "import": "./dist/index-react-bindings.browser.js",
-        "require": "./dist/index-react-bindings.browser.cjs"
-      },
-      "node": {
-        "import": "./dist/index-react-bindings.node.js",
-        "require": "./dist/index-react-bindings.node.cjs"
+        "import": "./dist/es/react-bindings.mjs",
+        "require": "./dist/cjs/react-bindings.js"
       },
-      "default": "./dist/index-react-bindings.node.js"
+      "import": "./dist/es/react-bindings.mjs",
+      "require": "./dist/cjs/react-bindings.js",
+      "default": "./dist/es/react-bindings.mjs"
     }
   },
   "types": "./dist/index.d.ts",
   "license": "See license in LICENSE",
   "scripts": {
     "clean": "rimraf dist",
-    "start": "rollup -w -c",
-    "build": "yarn clean && rollup -c",
+    "start": "yarn clean; concurrently 'vite build --watch' 'tsc --watch'",
+    "build": "yarn clean; concurrently 'vite build' 'tsc'",
     "test": "vitest",
     "test:unit": "vitest --exclude '__integration-tests__/**'",
     "test-ci": "vitest --exclude '__integration-tests__/docs-snippets/**' --coverage",
@@ -58,22 +46,22 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
+    "@stream-io/logger": "^1.1.4",
+    "@stream-io/state-store": "^1.1.4",
     "axios": "^1.7.7"
   },
   "devDependencies": {
-    "@rollup/plugin-replace": "^6.0.1",
-    "@rollup/plugin-typescript": "^12.1.0",
     "@stream-io/node-sdk": "0.6.0",
     "@types/react": "^19.1.8",
     "@vitest/coverage-v8": "3.2.4",
+    "concurrently": "^9.2.1",
     "dotenv": "^16.4.5",
     "human-id": "^4.1.1",
     "react": "19.0.0",
     "rimraf": "^6.0.1",
-    "rollup": "^4.24.0",
     "typescript": "^5.8.3",
-    "vite": "^5.4.8",
-    "vitest": "^3.2.1"
+    "vite": "^7.1.5",
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "react": "^18 || ^19"

package/src/bindings/index.ts

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

package/src/bindings/react/contexts/StreamFeedContext.tsx

@@ -0,0 +1,18 @@
+import { createContext, useContext } from 'react';
+import type { Feed } from '@self';
+
+export const StreamFeedContext = createContext<Feed | undefined>(undefined);
+
+/**
+ * The props for the StreamFeedProvider component.
+ */
+export type StreamFeedContextProps = {
+  feed: Feed;
+};
+
+/**
+ * Hook to access the nearest Feed instance.
+ */
+export const useFeedContext = () => {
+  return useContext(StreamFeedContext);
+};

package/src/bindings/react/contexts/StreamFeedsContext.tsx

@@ -0,0 +1,21 @@
+import { createContext, useContext } from 'react';
+import type { FeedsClient } from '@self';
+
+export const StreamFeedsContext = createContext<FeedsClient | undefined>(undefined);
+
+/**
+ * The props for the StreamFeedsProvider component.
+ */
+export type StreamFeedsContextProps = {
+  /**
+   * The client instance to provide to the component tree.
+   */
+  client: FeedsClient;
+};
+
+/**
+ * Hook to access the nearest FeedsClient instance.
+ */
+export const useFeedsClient = () => {
+  return useContext(StreamFeedsContext);
+};

package/src/bindings/react/contexts/StreamSearchContext.tsx

@@ -0,0 +1,18 @@
+import { createContext, useContext } from 'react';
+import type { SearchController } from '@self';
+
+export const StreamSearchContext = createContext<SearchController | undefined>(undefined);
+
+/**
+ * The props for the StreamSearchProvider component.
+ */
+export type StreamSearchContextProps = {
+  searchController: SearchController;
+};
+
+/**
+ * Hook to access the nearest SearchController instance.
+ */
+export const useSearchContext = () => {
+  return useContext(StreamSearchContext);
+};

package/src/bindings/react/contexts/StreamSearchResultsContext.tsx

@@ -0,0 +1,20 @@
+import { createContext, useContext } from 'react';
+import type { SearchSource } from '@self';
+
+export const StreamSearchResultsContext = createContext<
+  SearchSource | undefined
+>(undefined);
+
+/**
+ * The props for the StreamSearchResultsProvider component.
+ */
+export type StreamSearchResultsContextProps = {
+  source: SearchSource;
+};
+
+/**
+ * Hook to access the nearest SearchSource instance.
+ */
+export const useSearchResultsContext = () => {
+  return useContext(StreamSearchResultsContext);
+};

package/src/bindings/react/hooks/client-state-hooks/useClientConnectedUser.ts

@@ -0,0 +1,18 @@
+import type { FeedsClientState } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedsClient } from '../../contexts/StreamFeedsContext';
+
+/**
+ * A React hook that returns the currently connected user on a `FeedsClient` instance and null otherwise.
+ */
+export const useClientConnectedUser = () => {
+  const client = useFeedsClient();
+
+  const { user } = useStateStore(client?.state, selector) ?? {};
+
+  return user;
+};
+
+const selector = (nextState: FeedsClientState) => ({
+  user: nextState.connected_user,
+});

package/src/bindings/react/hooks/client-state-hooks/useWsConnectionState.ts

@@ -0,0 +1,18 @@
+import type { FeedsClientState } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedsClient } from '../../contexts/StreamFeedsContext';
+
+/**
+ * A React hook that returns the websocket connection state of `FeedsClient`.
+ */
+export const useWsConnectionState = () => {
+  const client = useFeedsClient();
+
+  const { is_healthy } = useStateStore(client?.state, selector) ?? {}
+
+  return { is_healthy };
+};
+
+const selector = (nextState: FeedsClientState) => ({
+  is_healthy: nextState.is_ws_connection_healthy,
+});

package/src/bindings/react/hooks/feed-state-hooks/useAggregatedActivities.ts

@@ -0,0 +1,25 @@
+import type { Feed, FeedState } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+
+const selector = ({ aggregated_activities }: FeedState) => ({
+  aggregated_activities,
+});
+
+type UseAggregatedActivitiesReturnType = ReturnType<typeof selector>;
+
+/**
+ * A React hook that returns a reactive object containing the current aggregated activities.
+ */
+export function useAggregatedActivities(
+  feedFromProps: Feed,
+): UseAggregatedActivitiesReturnType;
+export function useAggregatedActivities(
+  feedFromProps?: Feed,
+): UseAggregatedActivitiesReturnType | undefined;
+export function useAggregatedActivities(feedFromProps?: Feed) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  return useStateStore(feed?.state, selector);
+}

package/src/bindings/react/hooks/feed-state-hooks/useComments.ts

@@ -0,0 +1,91 @@
+import { useCallback, useMemo } from 'react';
+import {
+  type ActivityResponse,
+  type CommentResponse,
+  type CommentParent,
+  type Feed,
+  type FeedState,
+  checkHasAnotherPage,
+  isCommentResponse,
+} from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+
+type UseCommentsReturnType<T extends ActivityResponse | CommentResponse> = {
+  comments: NonNullable<
+    FeedState['comments_by_entity_id'][T['id']]
+  >['comments'];
+  comments_pagination: NonNullable<
+    FeedState['comments_by_entity_id'][T['id']]
+  >['pagination'];
+  has_next_page: boolean;
+  is_loading_next_page: boolean;
+  loadNextPage: (
+    request?: T extends CommentResponse
+      ? Parameters<Feed['loadNextPageCommentReplies']>[1]
+      : Parameters<Feed['loadNextPageActivityComments']>[1],
+  ) => Promise<void>;
+};
+
+export function useComments<T extends CommentParent>(_: {
+  feed: Feed;
+  parent: T;
+}): UseCommentsReturnType<T>;
+export function useComments<T extends CommentParent>(_: {
+  feed?: Feed;
+  parent: T;
+}): UseCommentsReturnType<T> | undefined;
+export function useComments<T extends CommentParent>({
+  feed: feedFromProps,
+  parent,
+}: {
+  feed?: Feed;
+  /**
+   * The parent (activity or comment) for which to fetch comments.
+   */
+  parent: T;
+}) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  const selector = useCallback(
+    (state: FeedState) => ({
+      comments: state.comments_by_entity_id?.[parent.id]?.comments,
+      comments_pagination: state.comments_by_entity_id?.[parent.id]?.pagination,
+    }),
+    [parent.id],
+  );
+
+  const data = useStateStore(feed?.state, selector);
+
+  const loadNextPage = useMemo<
+    UseCommentsReturnType<T>['loadNextPage'] | undefined
+  >(() => {
+    if (!feed) return undefined;
+
+    return (request) => {
+      if (isCommentResponse(parent)) {
+        return feed.loadNextPageCommentReplies(parent, request);
+      } else {
+        return feed.loadNextPageActivityComments(parent, request);
+      }
+    };
+  }, [feed, parent]);
+
+  return useMemo(() => {
+    if (!data) {
+      return undefined;
+    }
+
+    return {
+      ...data,
+      has_next_page: checkHasAnotherPage(
+        data.comments,
+        data.comments_pagination?.next,
+      ),
+      is_loading_next_page:
+        data?.comments_pagination?.loading_next_page ?? false,
+      loadNextPage,
+    };
+  }, [data, loadNextPage]);
+}

package/src/bindings/react/hooks/feed-state-hooks/useFeedActivities.ts

@@ -0,0 +1,36 @@
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+import type { Feed, FeedState } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useMemo } from 'react';
+import { useStableCallback } from '../internal';
+
+/**
+ * A React hook that returns a reactive object containing the current activities,
+ * loading state and whether there is a next page to paginate to or not.
+ */
+export const useFeedActivities = (feedFromProps?: Feed) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  const data = useStateStore(feed?.state, selector);
+
+  const loadNextPage = useStableCallback(async () => {
+    if (!feed || !data?.has_next_page || data?.is_loading) {
+      return;
+    }
+
+    await feed.getNextPage();
+  });
+
+  return useMemo(() => ({ ...data, loadNextPage }), [data, loadNextPage]);
+};
+
+const selector = ({
+  is_loading_activities,
+  next,
+  activities = [],
+}: FeedState) => ({
+  is_loading: is_loading_activities,
+  has_next_page: typeof next !== 'undefined',
+  activities,
+});

package/src/bindings/react/hooks/feed-state-hooks/useFeedMetadata.ts

@@ -0,0 +1,28 @@
+import type { Feed, FeedState } from '@self';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+
+/**
+ * A React hook that returns a reactive object containing some often used
+ * metadata for a feed.
+ */
+export const useFeedMetadata = (feedFromProps?: Feed) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  return useStateStore(feed?.state, selector);
+};
+
+const selector = ({
+  follower_count = 0,
+  following_count = 0,
+  created_by,
+  created_at,
+  updated_at,
+}: FeedState) => ({
+  created_by,
+  follower_count,
+  following_count,
+  created_at,
+  updated_at,
+});

package/src/bindings/react/hooks/feed-state-hooks/useFollowers.ts

@@ -0,0 +1,54 @@
+import { useCallback, useMemo } from 'react';
+import { type Feed, type FeedState, checkHasAnotherPage } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+
+const selector = ({
+  follower_count,
+  followers,
+  followers_pagination,
+}: FeedState) => ({
+  follower_count,
+  followers,
+  followers_pagination,
+});
+
+type UseFollowersReturnType = ReturnType<typeof selector> & {
+  is_loading_next_page: boolean;
+  has_next_page: boolean;
+  loadNextPage: (
+    ...options: Parameters<Feed['loadNextPageFollowers']>
+  ) => Promise<void>;
+};
+
+export function useFollowers(feed: Feed): UseFollowersReturnType;
+export function useFollowers(feed?: Feed): UseFollowersReturnType | undefined;
+export function useFollowers(feedFromProps?: Feed) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  const data = useStateStore(feed?.state, selector);
+
+  const loadNextPage = useCallback(
+    (...options: Parameters<Feed['loadNextPageFollowers']>) =>
+      feed?.loadNextPageFollowers(...options),
+    [feed],
+  );
+
+  return useMemo(() => {
+    if (!data) {
+      return undefined;
+    }
+
+    return {
+      ...data,
+      is_loading_next_page:
+        data.followers_pagination?.loading_next_page ?? false,
+      has_next_page: checkHasAnotherPage(
+        data.followers,
+        data.followers_pagination?.next,
+      ),
+      loadNextPage,
+    };
+  }, [data, loadNextPage]);
+}

package/src/bindings/react/hooks/feed-state-hooks/useFollowing.ts

@@ -0,0 +1,54 @@
+import { useCallback, useMemo } from 'react';
+import { type Feed, type FeedState, checkHasAnotherPage } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+
+const selector = ({
+  following_count,
+  following,
+  following_pagination,
+}: FeedState) => ({
+  following_count,
+  following,
+  following_pagination,
+});
+
+type UseFollowingReturnType = ReturnType<typeof selector> & {
+  is_loading_next_page: boolean;
+  has_next_page: boolean;
+  loadNextPage: (
+    ...options: Parameters<Feed['loadNextPageFollowers']>
+  ) => Promise<void>;
+};
+
+export function useFollowing(feed: Feed): UseFollowingReturnType;
+export function useFollowing(feed?: Feed): UseFollowingReturnType | undefined;
+export function useFollowing(feedFromProps?: Feed) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  const data = useStateStore(feed?.state, selector);
+
+  const loadNextPage = useCallback(
+    (...options: Parameters<Feed['loadNextPageFollowing']>) =>
+      feed?.loadNextPageFollowing(...options),
+    [feed],
+  );
+
+  return useMemo(() => {
+    if (!data) {
+      return undefined;
+    }
+
+    return {
+      ...data,
+      is_loading_next_page:
+        data.following_pagination?.loading_next_page ?? false,
+      has_next_page: checkHasAnotherPage(
+        data.following,
+        data.following_pagination?.next,
+      ),
+      loadNextPage,
+    };
+  }, [data, loadNextPage]);
+}

package/src/bindings/react/hooks/feed-state-hooks/useIsAggregatedActivityRead.ts

@@ -0,0 +1,29 @@
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+import { useNotificationStatus } from './useNotificationStatus';
+import { useMemo } from 'react';
+import type { AggregatedActivityResponse, Feed } from '@self';
+
+export const useIsAggregatedActivityRead = ({
+  feed: feedFromProps,
+  aggregatedActivity,
+}: {
+  feed?: Feed;
+  aggregatedActivity: AggregatedActivityResponse;
+}) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  const { read_activities: readActivities /* last_read_at: lastReadAt */ } =
+    useNotificationStatus(feed) ?? {};
+
+  const group = aggregatedActivity.group;
+
+  return useMemo(
+    () =>
+      // FIXME: This part of the condition does not work as marking individual groups as read also updates the last_read_at. Should be uncommented once it's fixed on the backend.
+      // (lastReadAt &&
+      //   aggregatedActivity.updated_at.getTime() <= lastReadAt.getTime()) ||
+      (readActivities ?? []).includes(group),
+    [readActivities, group],
+  );
+};

package/src/bindings/react/hooks/feed-state-hooks/useIsAggregatedActivitySeen.ts

@@ -0,0 +1,28 @@
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+import { useNotificationStatus } from './useNotificationStatus';
+import { useMemo } from 'react';
+import type { AggregatedActivityResponse, Feed } from '@self';
+
+export const useIsAggregatedActivitySeen = ({
+  feed: feedFromProps,
+  aggregatedActivity,
+}: {
+  feed?: Feed;
+  aggregatedActivity: AggregatedActivityResponse;
+}) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  const { seen_activities: seenActivities, last_seen_at: lastSeenAt } =
+    useNotificationStatus(feed) ?? {};
+
+  const group = aggregatedActivity.group;
+
+  return useMemo(
+    () =>
+      (lastSeenAt &&
+        aggregatedActivity.updated_at.getTime() < lastSeenAt.getTime()) ||
+      (seenActivities ?? []).includes(group),
+    [lastSeenAt, aggregatedActivity.updated_at, seenActivities, group],
+  );
+};

package/src/bindings/react/hooks/feed-state-hooks/useNotificationStatus.ts

@@ -0,0 +1,28 @@
+import type { Feed, FeedState, NotificationStatusResponse } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+
+const selector = ({ notification_status }: FeedState) =>
+  ({
+    unread: notification_status?.unread ?? 0,
+    unseen: notification_status?.unseen ?? 0,
+    last_read_at: notification_status?.last_read_at,
+    last_seen_at: notification_status?.last_seen_at,
+    read_activities: notification_status?.read_activities,
+    seen_activities: notification_status?.seen_activities,
+  }) satisfies NotificationStatusResponse;
+
+type UseNotificationStatusReturnType = ReturnType<typeof selector>;
+
+export function useNotificationStatus(
+  feed: Feed,
+): UseNotificationStatusReturnType;
+export function useNotificationStatus(
+  feed?: Feed,
+): UseNotificationStatusReturnType | undefined;
+export function useNotificationStatus(feedFromProps?: Feed) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  return useStateStore(feed?.state, selector);
+}

package/src/bindings/react/hooks/feed-state-hooks/useOwnCapabilities.ts

@@ -0,0 +1,70 @@
+import { useMemo } from 'react';
+import { type Feed, type FeedState, FeedOwnCapability } from '@self';
+import { useStateStore } from '@stream-io/state-store/react-bindings';
+import { useFeedContext } from '../../contexts/StreamFeedContext';
+
+const stableEmptyArray: readonly FeedOwnCapability[] = [];
+
+const selector = (currentState: FeedState) => ({
+  oc: currentState.own_capabilities ?? stableEmptyArray,
+});
+
+type KebabToSnakeCase<S extends string> = S extends `${infer T}-${infer U}`
+  ? `${T}_${KebabToSnakeCase<U>}`
+  : S;
+
+export const useOwnCapabilities = (feedFromProps?: Feed) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+
+  const { oc = stableEmptyArray } = useStateStore(feed?.state, selector) ?? {};
+
+  return useMemo(
+    () =>
+      ({
+        can_add_activity: oc.indexOf(FeedOwnCapability.ADD_ACTIVITY) > -1,
+        can_add_activity_reaction:
+          oc.indexOf(FeedOwnCapability.ADD_ACTIVITY_REACTION) > -1,
+        can_add_comment: oc.indexOf(FeedOwnCapability.ADD_COMMENT) > -1,
+        can_add_comment_reaction:
+          oc.indexOf(FeedOwnCapability.ADD_COMMENT_REACTION) > -1,
+        can_bookmark_activity:
+          oc.indexOf(FeedOwnCapability.BOOKMARK_ACTIVITY) > -1,
+        can_create_feed: oc.indexOf(FeedOwnCapability.CREATE_FEED) > -1,
+        can_delete_bookmark: oc.indexOf(FeedOwnCapability.DELETE_BOOKMARK) > -1,
+        can_delete_comment: oc.indexOf(FeedOwnCapability.DELETE_COMMENT) > -1,
+        can_delete_feed: oc.indexOf(FeedOwnCapability.DELETE_FEED) > -1,
+        can_edit_bookmark: oc.indexOf(FeedOwnCapability.EDIT_BOOKMARK) > -1,
+        can_follow: oc.indexOf(FeedOwnCapability.FOLLOW) > -1,
+        can_remove_activity: oc.indexOf(FeedOwnCapability.REMOVE_ACTIVITY) > -1,
+        can_remove_activity_reaction:
+          oc.indexOf(FeedOwnCapability.REMOVE_ACTIVITY_REACTION) > -1,
+        can_remove_comment_reaction:
+          oc.indexOf(FeedOwnCapability.REMOVE_COMMENT_REACTION) > -1,
+        can_unfollow: oc.indexOf(FeedOwnCapability.UNFOLLOW) > -1,
+        can_update_feed: oc.indexOf(FeedOwnCapability.UPDATE_FEED) > -1,
+        can_invite_feed: oc.indexOf(FeedOwnCapability.INVITE_FEED) > -1,
+        can_join_feed: oc.indexOf(FeedOwnCapability.JOIN_FEED) > -1,
+        can_leave_feed: oc.indexOf(FeedOwnCapability.LEAVE_FEED) > -1,
+        can_manage_feed_group:
+          oc.indexOf(FeedOwnCapability.MANAGE_FEED_GROUP) > -1,
+        can_mark_activity: oc.indexOf(FeedOwnCapability.MARK_ACTIVITY) > -1,
+        can_pin_activity: oc.indexOf(FeedOwnCapability.PIN_ACTIVITY) > -1,
+        can_query_feed_members:
+          oc.indexOf(FeedOwnCapability.QUERY_FEED_MEMBERS) > -1,
+        can_query_follows: oc.indexOf(FeedOwnCapability.QUERY_FOLLOWS) > -1,
+        can_read_activities: oc.indexOf(FeedOwnCapability.READ_ACTIVITIES) > -1,
+        can_read_feed: oc.indexOf(FeedOwnCapability.READ_FEED) > -1,
+        can_update_activity: oc.indexOf(FeedOwnCapability.UPDATE_ACTIVITY) > -1,
+        can_update_comment: oc.indexOf(FeedOwnCapability.UPDATE_COMMENT) > -1,
+        can_update_feed_followers:
+          oc.indexOf(FeedOwnCapability.UPDATE_FEED_FOLLOWERS) > -1,
+        can_update_feed_members:
+          oc.indexOf(FeedOwnCapability.UPDATE_FEED_MEMBERS) > -1,
+      }) satisfies Record<
+        `can_${KebabToSnakeCase<(typeof FeedOwnCapability)[keyof typeof FeedOwnCapability]>}`,
+        boolean
+      >,
+    [oc],
+  );
+};