@stream-io/feeds-client 0.2.6 → 0.2.8

package/dist/es/react-bindings.mjs

@@ -0,0 +1,1368 @@
+import require$$0, { useCallback, useMemo, useState, useEffect, createContext, useContext, useRef } from "react";
+import "@stream-io/state-store";
+import { F as FeedsClient, j as isCommentResponse, e as checkHasAnotherPage, b as FeedOwnCapability } from "../index-DLC5hiNd.mjs";
+import "@stream-io/logger";
+import "axios";
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_production;
+function requireUseSyncExternalStoreShim_production() {
+  if (hasRequiredUseSyncExternalStoreShim_production) return useSyncExternalStoreShim_production;
+  hasRequiredUseSyncExternalStoreShim_production = 1;
+  var React = require$$0;
+  function is(x, y) {
+    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+  }
+  var objectIs = "function" === typeof Object.is ? Object.is : is, useState2 = React.useState, useEffect2 = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+  function useSyncExternalStore$2(subscribe, getSnapshot) {
+    var value = getSnapshot(), _useState = useState2({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
+    useLayoutEffect(
+      function() {
+        inst.value = value;
+        inst.getSnapshot = getSnapshot;
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+      },
+      [subscribe, value, getSnapshot]
+    );
+    useEffect2(
+      function() {
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        return subscribe(function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        });
+      },
+      [subscribe]
+    );
+    useDebugValue(value);
+    return value;
+  }
+  function checkIfSnapshotChanged(inst) {
+    var latestGetSnapshot = inst.getSnapshot;
+    inst = inst.value;
+    try {
+      var nextValue = latestGetSnapshot();
+      return !objectIs(inst, nextValue);
+    } catch (error) {
+      return true;
+    }
+  }
+  function useSyncExternalStore$1(subscribe, getSnapshot) {
+    return getSnapshot();
+  }
+  var shim2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+  useSyncExternalStoreShim_production.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim2;
+  return useSyncExternalStoreShim_production;
+}
+var useSyncExternalStoreShim_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    function useSyncExternalStore$2(subscribe, getSnapshot) {
+      didWarnOld18Alpha || void 0 === React.startTransition || (didWarnOld18Alpha = true, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var value = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedValue = getSnapshot();
+        objectIs(value, cachedValue) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), didWarnUncachedGetSnapshot = true);
+      }
+      cachedValue = useState2({
+        inst: { value, getSnapshot }
+      });
+      var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+      useLayoutEffect(
+        function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        },
+        [subscribe, value, getSnapshot]
+      );
+      useEffect2(
+        function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          return subscribe(function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          });
+        },
+        [subscribe]
+      );
+      useDebugValue(value);
+      return value;
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return true;
+      }
+    }
+    function useSyncExternalStore$1(subscribe, getSnapshot) {
+      return getSnapshot();
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var React = require$$0, objectIs = "function" === typeof Object.is ? Object.is : is, useState2 = React.useState, useEffect2 = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+    useSyncExternalStoreShim_development.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim2;
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }();
+  return useSyncExternalStoreShim_development;
+}
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim.exports;
+  hasRequiredShim = 1;
+  if (process.env.NODE_ENV === "production") {
+    shim.exports = requireUseSyncExternalStoreShim_production();
+  } else {
+    shim.exports = requireUseSyncExternalStoreShim_development();
+  }
+  return shim.exports;
+}
+var shimExports = requireShim();
+const isPatch = (value) => typeof value === "function";
+const noop$1 = () => {
+};
+class StateStore {
+  constructor(value) {
+    this.value = value;
+    this.handlers = /* @__PURE__ */ new Set();
+    this.preprocessors = /* @__PURE__ */ new Set();
+    this.partialNext = (partial) => this.next((current) => ({ ...current, ...partial }));
+    this.subscribeWithSelector = (selector2, handler) => {
+      let previouslySelectedValues;
+      const wrappedHandler = (nextValue) => {
+        const newlySelectedValues = selector2(nextValue);
+        const selectionsAreEqual = StateStore.doSelectionsEqual(previouslySelectedValues, newlySelectedValues);
+        if (selectionsAreEqual)
+          return;
+        const previouslySelectedValuesCopy = previouslySelectedValues;
+        previouslySelectedValues = newlySelectedValues;
+        handler(newlySelectedValues, previouslySelectedValuesCopy);
+      };
+      return this.subscribe(wrappedHandler);
+    };
+  }
+  /**
+   * Allows merging two stores only if their keys differ otherwise there's no way to ensure the data type stability.
+   * @experimental
+   * This method is experimental and may change in future versions.
+   */
+  merge(stateStore) {
+    return new MergedStateStore({
+      original: this,
+      merged: stateStore
+    });
+  }
+  next(newValueOrPatch) {
+    const newValue = isPatch(newValueOrPatch) ? newValueOrPatch(this.value) : newValueOrPatch;
+    if (Object.is(newValue, this.value))
+      return;
+    this.preprocessors.forEach((preprocessor) => preprocessor(newValue, this.value));
+    const oldValue = this.value;
+    this.value = newValue;
+    this.handlers.forEach((handler) => handler(this.value, oldValue));
+  }
+  getLatestValue() {
+    return this.value;
+  }
+  subscribe(handler) {
+    handler(this.value, void 0);
+    this.handlers.add(handler);
+    return () => {
+      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.
+   *
+   * Preprocessors are invoked with the new and previous values whenever `next` or `partialNext` methods
+   * are called, allowing you to mutate or react to the new value before it is set. Preprocessors run in the
+   * order they were registered.
+   *
+   * @example
+   * ```ts
+   * const store = new StateStore<{ count: number; isMaxValue: bool; }>({ count: 0, isMaxValue: false });
+   *
+   * store.addPreprocessor((nextValue, prevValue) => {
+   *   if (nextValue.count > 10) {
+   *     nextValue.count = 10; // Clamp the value to a maximum of 10
+   *   }
+   *
+   *   if (nextValue.count === 10) {
+   *     nextValue.isMaxValue = true; // Set isMaxValue to true if count is 10
+   *   } else {
+   *     nextValue.isMaxValue = false; // Reset isMaxValue otherwise
+   *   }
+   * });
+   *
+   * store.partialNext({ count: 15 });
+   *
+   * store.getLatestValue(); // { count: 10, isMaxValue: true }
+   *
+   * store.partialNext({ count: 5 });
+   *
+   * store.getLatestValue(); // { count: 5, isMaxValue: false }
+   * ```
+   *
+   * @param preprocessor - The function to be called with the next and previous values before the state is updated.
+   * @returns A `RemovePreprocessor` function that removes the preprocessor when called.
+   */
+  addPreprocessor(preprocessor) {
+    this.preprocessors.add(preprocessor);
+    return () => {
+      this.preprocessors.delete(preprocessor);
+    };
+  }
+}
+class MergedStateStore extends StateStore {
+  constructor({ original, merged }) {
+    const originalValue = original.getLatestValue();
+    const mergedValue = merged.getLatestValue();
+    super({
+      ...originalValue,
+      ...mergedValue
+    });
+    this.next = () => {
+      console.warn(`${MergedStateStore.name}.next is disabled, call original.next or merged.next instead`);
+    };
+    this.partialNext = () => {
+      console.warn(`${MergedStateStore.name}.partialNext is disabled, call original.partialNext or merged.partialNext instead`);
+    };
+    this.cachedOriginalValue = originalValue;
+    this.cachedMergedValue = mergedValue;
+    this.original = original;
+    this.merged = merged;
+  }
+  /**
+   * Subscribes to changes in the merged state store.
+   *
+   * This method extends the base subscribe functionality to handle the merged nature of this store:
+   * 1. The first subscriber triggers registration of helper subscribers that listen to both source stores
+   * 2. Changes from either source store are propagated to this merged store
+   * 3. Source store values are cached to prevent unnecessary updates
+   *
+   * When the first subscriber is added, the method sets up listeners on both original and merged stores.
+   * These listeners update the combined store value whenever either source store changes.
+   * All subscriptions (helpers and the actual handler) are tracked so they can be properly cleaned up.
+   *
+   * @param handler - The callback function that will be executed when the state changes
+   * @returns An unsubscribe function that, when called, removes the subscription and any helper subscriptions
+   */
+  subscribe(handler) {
+    const unsubscribeFunctions = [];
+    if (!this.handlers.size) {
+      const base = (nextValue) => {
+        super.next((currentValue) => ({
+          ...currentValue,
+          ...nextValue
+        }));
+      };
+      unsubscribeFunctions.push(this.original.subscribe((nextValue) => {
+        if (nextValue === this.cachedOriginalValue)
+          return;
+        this.cachedOriginalValue = nextValue;
+        base(nextValue);
+      }), this.merged.subscribe((nextValue) => {
+        if (nextValue === this.cachedMergedValue)
+          return;
+        this.cachedMergedValue = nextValue;
+        base(nextValue);
+      }));
+    }
+    unsubscribeFunctions.push(super.subscribe(handler));
+    return () => {
+      unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
+    };
+  }
+  /**
+   * Retrieves the latest combined state from both original and merged stores.
+   *
+   * This method extends the base getLatestValue functionality to ensure the merged store
+   * remains in sync with its source stores even when there are no active subscribers.
+   *
+   * When there are no handlers registered, the method:
+   * 1. Fetches the latest values from both source stores
+   * 2. Compares them with the cached values to detect changes
+   * 3. If changes are detected, updates the internal value and caches
+   *    the new source values to maintain consistency
+   *
+   * This approach ensures that calling getLatestValue() always returns the most
+   * up-to-date combined state, even if the merged store hasn't been actively
+   * receiving updates through subscriptions.
+   *
+   * @returns The latest combined state from both original and merged stores
+   */
+  getLatestValue() {
+    if (!this.handlers.size) {
+      const originalValue = this.original.getLatestValue();
+      const mergedValue = this.merged.getLatestValue();
+      if (originalValue !== this.cachedOriginalValue || mergedValue !== this.cachedMergedValue) {
+        this.value = {
+          ...originalValue,
+          ...mergedValue
+        };
+        this.cachedMergedValue = mergedValue;
+        this.cachedOriginalValue = originalValue;
+      }
+    }
+    return super.getLatestValue();
+  }
+  addPreprocessor() {
+    console.warn(`${MergedStateStore.name}.addPreprocessor is disabled, call original.addPreprocessor or merged.addPreprocessor instead`);
+    return noop$1;
+  }
+}
+const noop = () => {
+};
+function useStateStore(store, selector2) {
+  const wrappedSubscription = useCallback((onStoreChange) => {
+    const unsubscribe = store?.subscribeWithSelector(selector2, onStoreChange);
+    return unsubscribe ?? noop;
+  }, [store, selector2]);
+  const wrappedSnapshot = useMemo(() => {
+    let cachedTuple;
+    return () => {
+      const currentValue = store?.getLatestValue();
+      if (!currentValue)
+        return void 0;
+      if (cachedTuple && Object.is(cachedTuple[0], currentValue)) {
+        return cachedTuple[1];
+      }
+      const newlySelected = selector2(currentValue);
+      const selectionsAreEqual = StateStore.doSelectionsEqual(cachedTuple?.[1], newlySelected);
+      if (selectionsAreEqual)
+        return cachedTuple[1];
+      cachedTuple = [currentValue, newlySelected];
+      return cachedTuple[1];
+    };
+  }, [store, selector2]);
+  const state = shimExports.useSyncExternalStore(wrappedSubscription, wrappedSnapshot);
+  return state;
+}
+const useCreateFeedsClient = ({
+  apiKey,
+  tokenOrProvider,
+  userData,
+  options
+}) => {
+  const [client, setClient] = useState(
+    () => new FeedsClient(apiKey, options)
+  );
+  const [error, setError] = useState(null);
+  const [cachedUserData, setCachedUserData] = useState(userData);
+  const [cachedOptions] = useState(options);
+  if (error) {
+    throw error;
+  }
+  if (userData.id !== cachedUserData.id) {
+    setCachedUserData(userData);
+  }
+  useEffect(() => {
+    const _client = new FeedsClient(apiKey, cachedOptions);
+    const connectionPromise = _client.connectUser(cachedUserData, tokenOrProvider).then(() => {
+      setError(null);
+      console.log("Successfully connected user: ", cachedUserData.id);
+    }).catch((err) => {
+      setError(err);
+    });
+    setClient(_client);
+    return () => {
+      setClient(null);
+      connectionPromise.then(() => {
+        setError(null);
+        return _client.disconnectUser();
+      }).catch((err) => {
+        setError(err);
+      }).then(() => {
+        console.log(
+          `Connection for user "${cachedUserData.id}" has been closed`
+        );
+      });
+    };
+  }, [apiKey, cachedUserData, cachedOptions, tokenOrProvider]);
+  return client;
+};
+const StreamFeedsContext = createContext(void 0);
+const useFeedsClient = () => {
+  return useContext(StreamFeedsContext);
+};
+const useClientConnectedUser = () => {
+  const client = useFeedsClient();
+  const { user } = useStateStore(client?.state, selector$c) ?? {};
+  return user;
+};
+const selector$c = (nextState) => ({
+  user: nextState.connected_user
+});
+const useWsConnectionState = () => {
+  const client = useFeedsClient();
+  const { is_healthy } = useStateStore(client?.state, selector$b) ?? {};
+  return { is_healthy };
+};
+const selector$b = (nextState) => ({
+  is_healthy: nextState.is_ws_connection_healthy
+});
+const StreamFeedContext = createContext(void 0);
+const useFeedContext = () => {
+  return useContext(StreamFeedContext);
+};
+const useStableCallback = (callback) => {
+  const ref = useRef(callback);
+  ref.current = callback;
+  return useCallback((...args) => {
+    return ref.current(...args);
+  }, []);
+};
+const useFeedActivities = (feedFromProps) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  const data = useStateStore(feed?.state, selector$a);
+  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$a = ({
+  is_loading_activities,
+  next,
+  activities = []
+}) => ({
+  is_loading: is_loading_activities,
+  has_next_page: typeof next !== "undefined",
+  activities
+});
+function useComments({
+  feed: feedFromProps,
+  parent
+}) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  const selector2 = useCallback(
+    (state) => ({
+      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, selector2);
+  const loadNextPage = useMemo(() => {
+    if (!feed) return void 0;
+    return (request) => {
+      if (isCommentResponse(parent)) {
+        return feed.loadNextPageCommentReplies(parent, request);
+      } else {
+        return feed.loadNextPageActivityComments(parent, request);
+      }
+    };
+  }, [feed, parent]);
+  return useMemo(() => {
+    if (!data) {
+      return void 0;
+    }
+    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]);
+}
+const stableEmptyArray = [];
+const selector$9 = (currentState) => ({
+  oc: currentState.own_capabilities ?? stableEmptyArray
+});
+const useOwnCapabilities = (feedFromProps) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  const { oc = stableEmptyArray } = useStateStore(feed?.state, selector$9) ?? {};
+  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
+    }),
+    [oc]
+  );
+};
+const selector$8 = ({
+  follower_count,
+  followers,
+  followers_pagination
+}) => ({
+  follower_count,
+  followers,
+  followers_pagination
+});
+function useFollowers(feedFromProps) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  const data = useStateStore(feed?.state, selector$8);
+  const loadNextPage = useCallback(
+    (...options) => feed?.loadNextPageFollowers(...options),
+    [feed]
+  );
+  return useMemo(() => {
+    if (!data) {
+      return void 0;
+    }
+    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]);
+}
+const selector$7 = ({
+  following_count,
+  following,
+  following_pagination
+}) => ({
+  following_count,
+  following,
+  following_pagination
+});
+function useFollowing(feedFromProps) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  const data = useStateStore(feed?.state, selector$7);
+  const loadNextPage = useCallback(
+    (...options) => feed?.loadNextPageFollowing(...options),
+    [feed]
+  );
+  return useMemo(() => {
+    if (!data) {
+      return void 0;
+    }
+    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]);
+}
+const useFeedMetadata = (feedFromProps) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  return useStateStore(feed?.state, selector$6);
+};
+const selector$6 = ({
+  follower_count = 0,
+  following_count = 0,
+  created_by,
+  created_at,
+  updated_at
+}) => ({
+  created_by,
+  follower_count,
+  following_count,
+  created_at,
+  updated_at
+});
+const useOwnFollows = (feedFromProps) => {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  return useStateStore(feed?.state, selector$5);
+};
+const selector$5 = ({ own_follows }) => ({
+  own_follows
+});
+const selector$4 = ({ notification_status }) => ({
+  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
+});
+function useNotificationStatus(feedFromProps) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  return useStateStore(feed?.state, selector$4);
+}
+const selector$3 = ({ aggregated_activities }) => ({
+  aggregated_activities
+});
+function useAggregatedActivities(feedFromProps) {
+  const feedFromContext = useFeedContext();
+  const feed = feedFromProps ?? feedFromContext;
+  return useStateStore(feed?.state, selector$3);
+}
+const useIsAggregatedActivityRead = ({
+  feed: feedFromProps,
+  aggregatedActivity
+}) => {
+  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]
+  );
+};
+const useIsAggregatedActivitySeen = ({
+  feed: feedFromProps,
+  aggregatedActivity
+}) => {
+  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]
+  );
+};
+const StreamSearchResultsContext = createContext(void 0);
+const useSearchResultsContext = () => {
+  return useContext(StreamSearchResultsContext);
+};
+const useSearchResult = (sourceFromProps) => {
+  const sourceFromContext = useSearchResultsContext();
+  const source = sourceFromProps ?? sourceFromContext;
+  const { items, error, isLoading, hasNext } = useStateStore(source?.state, selector$2) ?? {};
+  const loadMore = useStableCallback(async () => {
+    if (hasNext) {
+      source?.search();
+    }
+  });
+  return useMemo(
+    () => ({ items, error, isLoading, hasNext, loadMore }),
+    [error, hasNext, isLoading, items, loadMore]
+  );
+};
+const selector$2 = ({
+  items,
+  isLoading,
+  hasNext,
+  lastQueryError
+}) => ({
+  items,
+  isLoading,
+  hasNext,
+  error: lastQueryError
+});
+const StreamSearchContext = createContext(void 0);
+const useSearchContext = () => {
+  return useContext(StreamSearchContext);
+};
+const useSearchQuery = (controllerFromProps) => {
+  const controllerFromState = useSearchContext();
+  const controller = controllerFromProps ?? controllerFromState;
+  return useStateStore(controller?.state, selector$1);
+};
+const selector$1 = ({ searchQuery }) => ({
+  searchQuery
+});
+const useSearchSources = (controllerFromProps) => {
+  const controllerFromState = useSearchContext();
+  const controller = controllerFromProps ?? controllerFromState;
+  return useStateStore(controller?.state, selector);
+};
+const selector = ({ sources }) => ({
+  sources
+});
+const useReactionActions = ({
+  entity,
+  type
+}) => {
+  const client = useFeedsClient();
+  const isComment = isCommentResponse(entity);
+  const hasOwnReaction = useMemo(
+    () => !!entity.own_reactions?.find((r) => r.type === type),
+    [entity.own_reactions, type]
+  );
+  const addReaction = useStableCallback(async () => {
+    await (isComment ? client?.addCommentReaction({ id: entity.id, type }) : client?.addReaction({ activity_id: entity.id, type }));
+  });
+  const removeReaction = useStableCallback(async () => {
+    await (isComment ? client?.deleteCommentReaction({ id: entity.id, type }) : client?.deleteActivityReaction({
+      activity_id: entity.id,
+      type
+    }));
+  });
+  const toggleReaction = useStableCallback(async () => {
+    if (hasOwnReaction) {
+      await removeReaction();
+    } else {
+      await addReaction();
+    }
+  });
+  return useMemo(
+    () => ({ addReaction, removeReaction, toggleReaction }),
+    [addReaction, removeReaction, toggleReaction]
+  );
+};
+const useBookmarkActions = ({
+  entity
+}) => {
+  const client = useFeedsClient();
+  const hasOwnBookmark = entity.own_bookmarks?.length > 0;
+  const addBookmark = useStableCallback(async () => {
+    await client?.addBookmark({ activity_id: entity.id });
+  });
+  const removeBookmark = useStableCallback(async () => {
+    await client?.deleteBookmark({ activity_id: entity.id });
+  });
+  const toggleBookmark = useStableCallback(async () => {
+    if (hasOwnBookmark) {
+      await removeBookmark();
+    } else {
+      await addBookmark();
+    }
+  });
+  return useMemo(
+    () => ({ addBookmark, removeBookmark, toggleBookmark }),
+    [addBookmark, removeBookmark, toggleBookmark]
+  );
+};
+var jsxRuntime = { exports: {} };
+var reactJsxRuntime_production = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredReactJsxRuntime_production;
+function requireReactJsxRuntime_production() {
+  if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+  hasRequiredReactJsxRuntime_production = 1;
+  var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  function jsxProd(type, config, maybeKey) {
+    var key = null;
+    void 0 !== maybeKey && (key = "" + maybeKey);
+    void 0 !== config.key && (key = "" + config.key);
+    if ("key" in config) {
+      maybeKey = {};
+      for (var propName in config)
+        "key" !== propName && (maybeKey[propName] = config[propName]);
+    } else maybeKey = config;
+    config = maybeKey.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type,
+      key,
+      ref: void 0 !== config ? config : null,
+      props: maybeKey
+    };
+  }
+  reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactJsxRuntime_production.jsx = jsxProd;
+  reactJsxRuntime_production.jsxs = jsxProd;
+  return reactJsxRuntime_production;
+}
+var reactJsxRuntime_development = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredReactJsxRuntime_development;
+function requireReactJsxRuntime_development() {
+  if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+  hasRequiredReactJsxRuntime_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type)
+        return type.$$typeof === REACT_CLIENT_REFERENCE$2 ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PORTAL_TYPE:
+          return "Portal";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+      }
+      if ("object" === typeof type)
+        switch ("number" === typeof type.tag && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), type.$$typeof) {
+          case REACT_CONTEXT_TYPE:
+            return (type.displayName || "Context") + ".Provider";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {
+            }
+        }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(
+          JSCompiler_inline_result,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          JSCompiler_inline_result$jscomp$0
+        );
+        return testStringCoercion(value);
+      }
+    }
+    function disabledLog() {
+    }
+    function disableLogs() {
+      if (0 === disabledDepth) {
+        prevLog = console.log;
+        prevInfo = console.info;
+        prevWarn = console.warn;
+        prevError = console.error;
+        prevGroup = console.group;
+        prevGroupCollapsed = console.groupCollapsed;
+        prevGroupEnd = console.groupEnd;
+        var props = {
+          configurable: true,
+          enumerable: true,
+          value: disabledLog,
+          writable: true
+        };
+        Object.defineProperties(console, {
+          info: props,
+          log: props,
+          warn: props,
+          error: props,
+          group: props,
+          groupCollapsed: props,
+          groupEnd: props
+        });
+      }
+      disabledDepth++;
+    }
+    function reenableLogs() {
+      disabledDepth--;
+      if (0 === disabledDepth) {
+        var props = { configurable: true, enumerable: true, writable: true };
+        Object.defineProperties(console, {
+          log: assign({}, props, { value: prevLog }),
+          info: assign({}, props, { value: prevInfo }),
+          warn: assign({}, props, { value: prevWarn }),
+          error: assign({}, props, { value: prevError }),
+          group: assign({}, props, { value: prevGroup }),
+          groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
+          groupEnd: assign({}, props, { value: prevGroupEnd })
+        });
+      }
+      0 > disabledDepth && console.error(
+        "disabledDepth fell below zero. This is a bug in React. Please file an issue."
+      );
+    }
+    function describeBuiltInComponentFrame(name) {
+      if (void 0 === prefix)
+        try {
+          throw Error();
+        } catch (x) {
+          var match = x.stack.trim().match(/\n( *(at )?)/);
+          prefix = match && match[1] || "";
+          suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
+        }
+      return "\n" + prefix + name + suffix;
+    }
+    function describeNativeComponentFrame(fn, construct) {
+      if (!fn || reentry) return "";
+      var frame = componentFrameCache.get(fn);
+      if (void 0 !== frame) return frame;
+      reentry = true;
+      frame = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var previousDispatcher = null;
+      previousDispatcher = ReactSharedInternals.H;
+      ReactSharedInternals.H = null;
+      disableLogs();
+      try {
+        var RunInRootFrame = {
+          DetermineComponentFrameRoot: function() {
+            try {
+              if (construct) {
+                var Fake = function() {
+                  throw Error();
+                };
+                Object.defineProperty(Fake.prototype, "props", {
+                  set: function() {
+                    throw Error();
+                  }
+                });
+                if ("object" === typeof Reflect && Reflect.construct) {
+                  try {
+                    Reflect.construct(Fake, []);
+                  } catch (x) {
+                    var control = x;
+                  }
+                  Reflect.construct(fn, [], Fake);
+                } else {
+                  try {
+                    Fake.call();
+                  } catch (x$0) {
+                    control = x$0;
+                  }
+                  fn.call(Fake.prototype);
+                }
+              } else {
+                try {
+                  throw Error();
+                } catch (x$1) {
+                  control = x$1;
+                }
+                (Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function() {
+                });
+              }
+            } catch (sample) {
+              if (sample && control && "string" === typeof sample.stack)
+                return [sample.stack, control.stack];
+            }
+            return [null, null];
+          }
+        };
+        RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
+        var namePropDescriptor = Object.getOwnPropertyDescriptor(
+          RunInRootFrame.DetermineComponentFrameRoot,
+          "name"
+        );
+        namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(
+          RunInRootFrame.DetermineComponentFrameRoot,
+          "name",
+          { value: "DetermineComponentFrameRoot" }
+        );
+        var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(), sampleStack = _RunInRootFrame$Deter[0], controlStack = _RunInRootFrame$Deter[1];
+        if (sampleStack && controlStack) {
+          var sampleLines = sampleStack.split("\n"), controlLines = controlStack.split("\n");
+          for (_RunInRootFrame$Deter = namePropDescriptor = 0; namePropDescriptor < sampleLines.length && !sampleLines[namePropDescriptor].includes(
+            "DetermineComponentFrameRoot"
+          ); )
+            namePropDescriptor++;
+          for (; _RunInRootFrame$Deter < controlLines.length && !controlLines[_RunInRootFrame$Deter].includes(
+            "DetermineComponentFrameRoot"
+          ); )
+            _RunInRootFrame$Deter++;
+          if (namePropDescriptor === sampleLines.length || _RunInRootFrame$Deter === controlLines.length)
+            for (namePropDescriptor = sampleLines.length - 1, _RunInRootFrame$Deter = controlLines.length - 1; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter && sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]; )
+              _RunInRootFrame$Deter--;
+          for (; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter; namePropDescriptor--, _RunInRootFrame$Deter--)
+            if (sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
+              if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) {
+                do
+                  if (namePropDescriptor--, _RunInRootFrame$Deter--, 0 > _RunInRootFrame$Deter || sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
+                    var _frame = "\n" + sampleLines[namePropDescriptor].replace(
+                      " at new ",
+                      " at "
+                    );
+                    fn.displayName && _frame.includes("<anonymous>") && (_frame = _frame.replace("<anonymous>", fn.displayName));
+                    "function" === typeof fn && componentFrameCache.set(fn, _frame);
+                    return _frame;
+                  }
+                while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
+              }
+              break;
+            }
+        }
+      } finally {
+        reentry = false, ReactSharedInternals.H = previousDispatcher, reenableLogs(), Error.prepareStackTrace = frame;
+      }
+      sampleLines = (sampleLines = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(sampleLines) : "";
+      "function" === typeof fn && componentFrameCache.set(fn, sampleLines);
+      return sampleLines;
+    }
+    function describeUnknownElementTypeFrameInDEV(type) {
+      if (null == type) return "";
+      if ("function" === typeof type) {
+        var prototype = type.prototype;
+        return describeNativeComponentFrame(
+          type,
+          !(!prototype || !prototype.isReactComponent)
+        );
+      }
+      if ("string" === typeof type) return describeBuiltInComponentFrame(type);
+      switch (type) {
+        case REACT_SUSPENSE_TYPE:
+          return describeBuiltInComponentFrame("Suspense");
+        case REACT_SUSPENSE_LIST_TYPE:
+          return describeBuiltInComponentFrame("SuspenseList");
+      }
+      if ("object" === typeof type)
+        switch (type.$$typeof) {
+          case REACT_FORWARD_REF_TYPE:
+            return type = describeNativeComponentFrame(type.render, false), type;
+          case REACT_MEMO_TYPE:
+            return describeUnknownElementTypeFrameInDEV(type.type);
+          case REACT_LAZY_TYPE:
+            prototype = type._payload;
+            type = type._init;
+            try {
+              return describeUnknownElementTypeFrameInDEV(type(prototype));
+            } catch (x) {
+            }
+        }
+      return "";
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return false;
+      }
+      return void 0 !== config.key;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          displayName
+        ));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      ));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
+    }
+    function ReactElement(type, key, self, source, owner, props) {
+      self = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, source, self) {
+      if ("string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_OFFSCREEN_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE$1 || void 0 !== type.getModuleId)) {
+        var children = config.children;
+        if (void 0 !== children)
+          if (isStaticChildren)
+            if (isArrayImpl(children)) {
+              for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+                validateChildKeys(children[isStaticChildren], type);
+              Object.freeze && Object.freeze(children);
+            } else
+              console.error(
+                "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+              );
+          else validateChildKeys(children, type);
+      } else {
+        children = "";
+        if (void 0 === type || "object" === typeof type && null !== type && 0 === Object.keys(type).length)
+          children += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
+        null === type ? isStaticChildren = "null" : isArrayImpl(type) ? isStaticChildren = "array" : void 0 !== type && type.$$typeof === REACT_ELEMENT_TYPE ? (isStaticChildren = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />", children = " Did you accidentally export a JSX literal instead of a component?") : isStaticChildren = typeof type;
+        console.error(
+          "React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s",
+          isStaticChildren,
+          children
+        );
+      }
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return "key" !== k;
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+          'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+          isStaticChildren,
+          children,
+          keys,
+          children
+        ), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      children && defineKeyPropWarningGetter(
+        maybeKey,
+        "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+      );
+      return ReactElement(type, children, self, source, getOwner(), maybeKey);
+    }
+    function validateChildKeys(node, parentType) {
+      if ("object" === typeof node && node && node.$$typeof !== REACT_CLIENT_REFERENCE) {
+        if (isArrayImpl(node))
+          for (var i = 0; i < node.length; i++) {
+            var child = node[i];
+            isValidElement(child) && validateExplicitKey(child, parentType);
+          }
+        else if (isValidElement(node))
+          node._store && (node._store.validated = 1);
+        else if (null === node || "object" !== typeof node ? i = null : (i = MAYBE_ITERATOR_SYMBOL && node[MAYBE_ITERATOR_SYMBOL] || node["@@iterator"], i = "function" === typeof i ? i : null), "function" === typeof i && i !== node.entries && (i = i.call(node), i !== node))
+          for (; !(node = i.next()).done; )
+            isValidElement(node.value) && validateExplicitKey(node.value, parentType);
+      }
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function validateExplicitKey(element, parentType) {
+      if (element._store && !element._store.validated && null == element.key && (element._store.validated = 1, parentType = getCurrentComponentErrorInfo(parentType), !ownerHasKeyUseWarning[parentType])) {
+        ownerHasKeyUseWarning[parentType] = true;
+        var childOwner = "";
+        element && null != element._owner && element._owner !== getOwner() && (childOwner = null, "number" === typeof element._owner.tag ? childOwner = getComponentNameFromType(element._owner.type) : "string" === typeof element._owner.name && (childOwner = element._owner.name), childOwner = " It was passed a child from " + childOwner + ".");
+        var prevGetCurrentStack = ReactSharedInternals.getCurrentStack;
+        ReactSharedInternals.getCurrentStack = function() {
+          var stack = describeUnknownElementTypeFrameInDEV(element.type);
+          prevGetCurrentStack && (stack += prevGetCurrentStack() || "");
+          return stack;
+        };
+        console.error(
+          'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
+          parentType,
+          childOwner
+        );
+        ReactSharedInternals.getCurrentStack = prevGetCurrentStack;
+      }
+    }
+    function getCurrentComponentErrorInfo(parentType) {
+      var info = "", owner = getOwner();
+      owner && (owner = getComponentNameFromType(owner.type)) && (info = "\n\nCheck the render method of `" + owner + "`.");
+      info || (parentType = getComponentNameFromType(parentType)) && (info = "\n\nCheck the top-level render call using <" + parentType + ">.");
+      return info;
+    }
+    var React = require$$0, REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, REACT_CLIENT_REFERENCE$2 = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, assign = Object.assign, REACT_CLIENT_REFERENCE$1 = Symbol.for("react.client.reference"), isArrayImpl = Array.isArray, disabledDepth = 0, prevLog, prevInfo, prevWarn, prevError, prevGroup, prevGroupCollapsed, prevGroupEnd;
+    disabledLog.__reactDisabledLog = true;
+    var prefix, suffix, reentry = false;
+    var componentFrameCache = new ("function" === typeof WeakMap ? WeakMap : Map)();
+    var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var didWarnAboutKeySpread = {}, ownerHasKeyUseWarning = {};
+    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+    reactJsxRuntime_development.jsx = function(type, config, maybeKey, source, self) {
+      return jsxDEVImpl(type, config, maybeKey, false, source, self);
+    };
+    reactJsxRuntime_development.jsxs = function(type, config, maybeKey, source, self) {
+      return jsxDEVImpl(type, config, maybeKey, true, source, self);
+    };
+  }();
+  return reactJsxRuntime_development;
+}
+var hasRequiredJsxRuntime;
+function requireJsxRuntime() {
+  if (hasRequiredJsxRuntime) return jsxRuntime.exports;
+  hasRequiredJsxRuntime = 1;
+  if (process.env.NODE_ENV === "production") {
+    jsxRuntime.exports = requireReactJsxRuntime_production();
+  } else {
+    jsxRuntime.exports = requireReactJsxRuntime_development();
+  }
+  return jsxRuntime.exports;
+}
+var jsxRuntimeExports = requireJsxRuntime();
+const StreamFeeds = ({ client, children }) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(StreamFeedsContext.Provider, { value: client, children });
+};
+StreamFeeds.displayName = "StreamFeeds";
+const StreamFeed = ({
+  feed,
+  children
+}) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(StreamFeedContext.Provider, { value: feed, children });
+};
+StreamFeed.displayName = "StreamFeed";
+const StreamSearch = ({
+  searchController,
+  children
+}) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(StreamSearchContext.Provider, { value: searchController, children });
+};
+StreamSearch.displayName = "StreamSearch";
+const StreamSearchResults = ({
+  source,
+  children
+}) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(StreamSearchResultsContext.Provider, { value: source, children });
+};
+StreamSearchResults.displayName = "StreamSearchResults";
+export {
+  StreamFeed,
+  StreamFeedContext,
+  StreamFeeds,
+  StreamFeedsContext,
+  StreamSearch,
+  StreamSearchContext,
+  StreamSearchResults,
+  StreamSearchResultsContext,
+  useAggregatedActivities,
+  useBookmarkActions,
+  useClientConnectedUser,
+  useComments,
+  useCreateFeedsClient,
+  useFeedActivities,
+  useFeedContext,
+  useFeedMetadata,
+  useFeedsClient,
+  useFollowers,
+  useFollowing,
+  useIsAggregatedActivityRead,
+  useIsAggregatedActivitySeen,
+  useNotificationStatus,
+  useOwnCapabilities,
+  useOwnFollows,
+  useReactionActions,
+  useSearchContext,
+  useSearchQuery,
+  useSearchResult,
+  useSearchResultsContext,
+  useSearchSources,
+  useStateStore,
+  useWsConnectionState
+};
+//# sourceMappingURL=react-bindings.mjs.map