stream-chat 9.3.0 → 9.5.0

package/dist/cjs/index.browser.cjs

@@ -159,6 +159,7 @@ __export(index_exports, {
   AnyResource: () => AnyResource,
   AnyRole: () => AnyRole,
   AttachmentManager: () => AttachmentManager,
+  BasePaginator: () => BasePaginator,
   BaseSearchSource: () => BaseSearchSource,
   BuiltinPermissions: () => BuiltinPermissions,
   BuiltinRoles: () => BuiltinRoles,
@@ -176,6 +177,9 @@ __export(index_exports, {
   DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS: () => DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS,
   DEFAULT_COMPOSER_CONFIG: () => DEFAULT_COMPOSER_CONFIG,
   DEFAULT_LINK_PREVIEW_MANAGER_CONFIG: () => DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
+  DEFAULT_PAGINATION_OPTIONS: () => DEFAULT_PAGINATION_OPTIONS,
+  DEFAULT_REMINDER_MANAGER_CONFIG: () => DEFAULT_REMINDER_MANAGER_CONFIG,
+  DEFAULT_STOP_REFRESH_BOUNDARY_MS: () => DEFAULT_STOP_REFRESH_BOUNDARY_MS,
   DEFAULT_TEXT_COMPOSER_CONFIG: () => DEFAULT_TEXT_COMPOSER_CONFIG,
   Deny: () => Deny,
   DenyAll: () => DenyAll,
@@ -192,6 +196,7 @@ __export(index_exports, {
   MODERATION_ENTITY_TYPES: () => MODERATION_ENTITY_TYPES,
   MaxPriority: () => MaxPriority,
   MentionsSearchSource: () => MentionsSearchSource,
+  MergedStateStore: () => MergedStateStore,
   MessageComposer: () => MessageComposer,
   MessageComposerMiddlewareExecutor: () => MessageComposerMiddlewareExecutor,
   MessageDraftComposerMiddlewareExecutor: () => MessageDraftComposerMiddlewareExecutor,
@@ -207,6 +212,10 @@ __export(index_exports, {
   PollComposerCompositionMiddlewareExecutor: () => PollComposerCompositionMiddlewareExecutor,
   PollComposerStateMiddlewareExecutor: () => PollComposerStateMiddlewareExecutor,
   PollManager: () => PollManager,
+  Reminder: () => Reminder,
+  ReminderManager: () => ReminderManager,
+  ReminderPaginator: () => ReminderPaginator,
+  ReminderTimer: () => ReminderTimer,
   SearchController: () => SearchController,
   Segment: () => Segment,
   StableWSConnection: () => StableWSConnection,
@@ -294,7 +303,8 @@ __export(index_exports, {
   readFileAsArrayBuffer: () => readFileAsArrayBuffer,
   removeDiacritics: () => removeDiacritics,
   replaceWordWithEntity: () => replaceWordWithEntity,
-  textIsEmpty: () => textIsEmpty
+  textIsEmpty: () => textIsEmpty,
+  timeLeftMs: () => timeLeftMs
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -4048,26 +4058,14 @@ var ensureIsLocalAttachment = (attachment) => {
 
 // src/store.ts
 var isPatch = (value) => typeof value === "function";
+var noop2 = () => {
+};
 var StateStore = class {
   constructor(value) {
     this.value = value;
-    this.handlerSet = /* @__PURE__ */ new Set();
-    this.next = (newValueOrPatch) => {
-      const newValue = isPatch(newValueOrPatch) ? newValueOrPatch(this.value) : newValueOrPatch;
-      if (newValue === this.value) return;
-      const oldValue = this.value;
-      this.value = newValue;
-      this.handlerSet.forEach((handler) => handler(this.value, oldValue));
-    };
+    this.handlers = /* @__PURE__ */ new Set();
+    this.preprocessors = /* @__PURE__ */ new Set();
     this.partialNext = (partial) => this.next((current) => ({ ...current, ...partial }));
-    this.getLatestValue = () => this.value;
-    this.subscribe = (handler) => {
-      handler(this.value, void 0);
-      this.handlerSet.add(handler);
-      return () => {
-        this.handlerSet.delete(handler);
-      };
-    };
     this.subscribeWithSelector = (selector, handler) => {
       let previouslySelectedValues;
       const wrappedHandler = (nextValue) => {
@@ -4086,6 +4084,183 @@ var StateStore = class {
       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.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  merge(stateStore) {
+    return new MergedStateStore({
+      original: this,
+      merged: stateStore
+    });
+  }
+  next(newValueOrPatch) {
+    const newValue = isPatch(newValueOrPatch) ? newValueOrPatch(this.value) : newValueOrPatch;
+    if (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);
+    };
+  }
+  /**
+   * 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);
+    };
+  }
+};
+var MergedStateStore = class _MergedStateStore extends StateStore {
+  constructor({ original, merged }) {
+    const originalValue = original.getLatestValue();
+    const mergedValue = merged.getLatestValue();
+    super({
+      ...originalValue,
+      ...mergedValue
+    });
+    // override original methods and "disable" them
+    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 noop2;
+  }
 };
 
 // src/utils/mergeWith/mergeWithCore.ts
@@ -5505,7 +5680,9 @@ var ErrorFromResponse = class extends Error {
     return {
       message: `(${joinable.join(", ")}) - ${this.message}`,
       stack: this.stack,
-      name: this.name
+      name: this.name,
+      code: this.code,
+      status: this.status
     };
   }
 };
@@ -6073,7 +6250,7 @@ var MessageDraftComposerMiddlewareExecutor = class extends MiddlewareExecutor {
   }
 };
 
-// src/search_controller.ts
+// src/search/BaseSearchSource.ts
 var DEFAULT_SEARCH_SOURCE_OPTIONS = {
   debounceMs: 300,
   pageSize: 10
@@ -6199,6 +6376,112 @@ var BaseSearchSource = class {
     this.activate();
   }
 };
+
+// src/search/SearchController.ts
+var SearchController = class {
+  constructor({ config, sources } = {}) {
+    this.addSource = (source) => {
+      this.state.partialNext({
+        sources: [...this.sources, source]
+      });
+    };
+    this.getSource = (sourceType) => this.sources.find((s) => s.type === sourceType);
+    this.removeSource = (sourceType) => {
+      const newSources = this.sources.filter((s) => s.type !== sourceType);
+      if (newSources.length === this.sources.length) return;
+      this.state.partialNext({ sources: newSources });
+    };
+    this.activateSource = (sourceType) => {
+      const source = this.getSource(sourceType);
+      if (!source || source.isActive) return;
+      if (this.config.keepSingleActiveSource) {
+        this.sources.forEach((s) => {
+          if (s.type !== sourceType) {
+            s.deactivate();
+          }
+        });
+      }
+      source.activate();
+      this.state.partialNext({ sources: [...this.sources] });
+    };
+    this.deactivateSource = (sourceType) => {
+      const source = this.getSource(sourceType);
+      if (!source?.isActive) return;
+      if (this.activeSources.length === 1) return;
+      source.deactivate();
+      this.state.partialNext({ sources: [...this.sources] });
+    };
+    this.activate = () => {
+      if (!this.activeSources.length) {
+        const sourcesToActivate = this.config.keepSingleActiveSource ? this.sources.slice(0, 1) : this.sources;
+        sourcesToActivate.forEach((s) => s.activate());
+      }
+      if (this.isActive) return;
+      this.state.partialNext({ isActive: true });
+    };
+    this.search = async (searchQuery) => {
+      const searchedSources = this.activeSources;
+      this.state.partialNext({
+        searchQuery
+      });
+      await Promise.all(searchedSources.map((source) => source.search(searchQuery)));
+    };
+    this.cancelSearchQueries = () => {
+      this.activeSources.forEach((s) => s.cancelScheduledQuery());
+    };
+    this.clear = () => {
+      this.cancelSearchQueries();
+      this.sources.forEach(
+        (source) => source.state.next({ ...source.initialState, isActive: source.isActive })
+      );
+      this.state.next((current) => ({
+        ...current,
+        isActive: true,
+        queriesInProgress: [],
+        searchQuery: ""
+      }));
+    };
+    this.exit = () => {
+      this.cancelSearchQueries();
+      this.sources.forEach(
+        (source) => source.state.next({ ...source.initialState, isActive: source.isActive })
+      );
+      this.state.next((current) => ({
+        ...current,
+        isActive: false,
+        queriesInProgress: [],
+        searchQuery: ""
+      }));
+    };
+    this.state = new StateStore({
+      isActive: false,
+      searchQuery: "",
+      sources: sources ?? []
+    });
+    this._internalState = new StateStore({});
+    this.config = { keepSingleActiveSource: true, ...config };
+  }
+  get hasNext() {
+    return this.sources.some((source) => source.hasNext);
+  }
+  get sources() {
+    return this.state.getLatestValue().sources;
+  }
+  get activeSources() {
+    return this.state.getLatestValue().sources.filter((s) => s.isActive);
+  }
+  get isActive() {
+    return this.state.getLatestValue().isActive;
+  }
+  get searchQuery() {
+    return this.state.getLatestValue().searchQuery;
+  }
+  get searchSourceTypes() {
+    return this.sources.map((s) => s.type);
+  }
+};
+
+// src/search/UserSearchSource.ts
 var UserSearchSource = class extends BaseSearchSource {
   constructor(client, options) {
     super(options);
@@ -6222,6 +6505,8 @@ var UserSearchSource = class extends BaseSearchSource {
     return items.filter((u) => u.id !== this.client.user?.id);
   }
 };
+
+// src/search/ChannelSearchSource.ts
 var ChannelSearchSource = class extends BaseSearchSource {
   constructor(client, options) {
     super(options);
@@ -6243,6 +6528,8 @@ var ChannelSearchSource = class extends BaseSearchSource {
     return items;
   }
 };
+
+// src/search/MessageSearchSource.ts
 var MessageSearchSource = class extends BaseSearchSource {
   constructor(client, options) {
     super(options);
@@ -6303,108 +6590,6 @@ var MessageSearchSource = class extends BaseSearchSource {
     return items;
   }
 };
-var SearchController = class {
-  constructor({ config, sources } = {}) {
-    this.addSource = (source) => {
-      this.state.partialNext({
-        sources: [...this.sources, source]
-      });
-    };
-    this.getSource = (sourceType) => this.sources.find((s) => s.type === sourceType);
-    this.removeSource = (sourceType) => {
-      const newSources = this.sources.filter((s) => s.type !== sourceType);
-      if (newSources.length === this.sources.length) return;
-      this.state.partialNext({ sources: newSources });
-    };
-    this.activateSource = (sourceType) => {
-      const source = this.getSource(sourceType);
-      if (!source || source.isActive) return;
-      if (this.config.keepSingleActiveSource) {
-        this.sources.forEach((s) => {
-          if (s.type !== sourceType) {
-            s.deactivate();
-          }
-        });
-      }
-      source.activate();
-      this.state.partialNext({ sources: [...this.sources] });
-    };
-    this.deactivateSource = (sourceType) => {
-      const source = this.getSource(sourceType);
-      if (!source?.isActive) return;
-      if (this.activeSources.length === 1) return;
-      source.deactivate();
-      this.state.partialNext({ sources: [...this.sources] });
-    };
-    this.activate = () => {
-      if (!this.activeSources.length) {
-        const sourcesToActivate = this.config.keepSingleActiveSource ? this.sources.slice(0, 1) : this.sources;
-        sourcesToActivate.forEach((s) => s.activate());
-      }
-      if (this.isActive) return;
-      this.state.partialNext({ isActive: true });
-    };
-    this.search = async (searchQuery) => {
-      const searchedSources = this.activeSources;
-      this.state.partialNext({
-        searchQuery
-      });
-      await Promise.all(searchedSources.map((source) => source.search(searchQuery)));
-    };
-    this.cancelSearchQueries = () => {
-      this.activeSources.forEach((s) => s.cancelScheduledQuery());
-    };
-    this.clear = () => {
-      this.cancelSearchQueries();
-      this.sources.forEach(
-        (source) => source.state.next({ ...source.initialState, isActive: source.isActive })
-      );
-      this.state.next((current) => ({
-        ...current,
-        isActive: true,
-        queriesInProgress: [],
-        searchQuery: ""
-      }));
-    };
-    this.exit = () => {
-      this.cancelSearchQueries();
-      this.sources.forEach(
-        (source) => source.state.next({ ...source.initialState, isActive: source.isActive })
-      );
-      this.state.next((current) => ({
-        ...current,
-        isActive: false,
-        queriesInProgress: [],
-        searchQuery: ""
-      }));
-    };
-    this.state = new StateStore({
-      isActive: false,
-      searchQuery: "",
-      sources: sources ?? []
-    });
-    this._internalState = new StateStore({});
-    this.config = { keepSingleActiveSource: true, ...config };
-  }
-  get hasNext() {
-    return this.sources.some((source) => source.hasNext);
-  }
-  get sources() {
-    return this.state.getLatestValue().sources;
-  }
-  get activeSources() {
-    return this.state.getLatestValue().sources.filter((s) => s.isActive);
-  }
-  get isActive() {
-    return this.state.getLatestValue().isActive;
-  }
-  get searchQuery() {
-    return this.state.getLatestValue().searchQuery;
-  }
-  get searchSourceTypes() {
-    return this.sources.map((s) => s.type);
-  }
-};
 
 // src/messageComposer/middleware/textComposer/textMiddlewareUtils.ts
 var getTriggerCharWithToken = ({
@@ -7638,7 +7823,7 @@ var initState5 = (composition) => {
     pollId: message.poll_id ?? null
   };
 };
-var noop2 = () => void 0;
+var noop3 = () => void 0;
 var _MessageComposer = class _MessageComposer extends WithSubscriptions {
   // todo: mediaRecorder: MediaRecorderController;
   constructor({
@@ -7666,7 +7851,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     this.initEditingAuditState = (composition) => initEditingAuditState(composition);
     this.registerSubscriptions = () => {
       if (this.hasSubscriptions) {
-        return noop2;
+        return noop3;
       }
       this.addUnsubscribeFunction(this.subscribeMessageComposerSetupStateChange());
       this.addUnsubscribeFunction(this.subscribeMessageUpdated());
@@ -9183,6 +9368,7 @@ var Channel = class {
       })
     };
     this.getClient().polls.hydratePollCache(state.messages, true);
+    this.getClient().reminders.hydrateState(state.messages);
     if (state.draft) {
       this.messageComposer.initState({ composition: state.draft });
     }
@@ -10474,7 +10660,9 @@ var TokenManager = class {
           try {
             this.token = await this.tokenProvider();
           } catch (e) {
-            return reject(new Error(`Call to tokenProvider failed with message: ${e}`));
+            return reject(
+              new Error(`Call to tokenProvider failed with message: ${e}`, { cause: e })
+            );
           }
           resolve(this.token);
         }
@@ -12224,6 +12412,458 @@ var NotificationManager = class {
   }
 };
 
+// src/reminders/ReminderTimer.ts
+var oneMinute = 60 * 1e3;
+var oneHour = 60 * oneMinute;
+var oneDay = 24 * oneHour;
+var oneWeek = 7 * oneDay;
+var GROUP_BOUNDS = {
+  minute: { lower: oneMinute, upper: oneHour },
+  hour: { lower: oneHour, upper: oneDay },
+  day: { lower: oneDay, upper: oneWeek }
+};
+var DEFAULT_STOP_REFRESH_BOUNDARY_MS = 2 * oneWeek;
+var ReminderTimer = class {
+  constructor({
+    reminder,
+    config
+  }) {
+    this.timeout = null;
+    this.stopRefreshBoundaryMs = DEFAULT_STOP_REFRESH_BOUNDARY_MS;
+    this.getRefreshIntervalLength = () => {
+      if (!this.reminder.remindAt) return null;
+      const distanceFromDeadlineMs = Math.abs(timeLeftMs(this.reminder.remindAt.getTime()));
+      let refreshInterval;
+      if (distanceFromDeadlineMs === 0) {
+        refreshInterval = oneMinute;
+      } else if (distanceFromDeadlineMs < GROUP_BOUNDS.minute.lower) {
+        refreshInterval = distanceFromDeadlineMs;
+      } else if (distanceFromDeadlineMs <= GROUP_BOUNDS.minute.upper) {
+        refreshInterval = oneMinute;
+      } else if (distanceFromDeadlineMs <= GROUP_BOUNDS.hour.upper) {
+        refreshInterval = oneHour;
+      } else {
+        refreshInterval = oneDay;
+      }
+      return refreshInterval;
+    };
+    this.init = () => {
+      if (!this.reminder.remindAt) return null;
+      const timeoutLength = this.getRefreshIntervalLength();
+      if (timeoutLength === null) return null;
+      const boundaryTimestamp = this.reminder.remindAt?.getTime() + this.stopRefreshBoundaryMs;
+      const timeLeftToBoundary = boundaryTimestamp - Date.now();
+      if (timeLeftToBoundary <= 0) {
+        this.timeout = null;
+        return;
+      }
+      if (this.timeout) clearTimeout(this.timeout);
+      this.timeout = setTimeout(() => {
+        this.reminder.refreshTimeLeft();
+        this.init();
+      }, timeoutLength);
+    };
+    this.clear = () => {
+      if (this.timeout) {
+        clearInterval(this.timeout);
+        this.timeout = null;
+      }
+    };
+    this.reminder = reminder;
+    if (typeof config?.stopRefreshBoundaryMs === "number") {
+      this.stopRefreshBoundaryMs = config.stopRefreshBoundaryMs;
+    }
+  }
+};
+
+// src/reminders/Reminder.ts
+var timeLeftMs = (remindAt) => remindAt - (/* @__PURE__ */ new Date()).getTime();
+var _Reminder = class _Reminder {
+  constructor({ data, config }) {
+    this.setState = (data) => {
+      this.state.next((current) => {
+        const newState = { ...current, ..._Reminder.toStateValue(data) };
+        if (newState.remind_at) {
+          newState.timeLeftMs = timeLeftMs(newState.remind_at.getTime());
+        }
+        return newState;
+      });
+      if (data.remind_at) {
+        this.initTimer();
+      } else if (!data.remind_at) {
+        this.clearTimer();
+      }
+    };
+    this.refreshTimeLeft = () => {
+      if (!this.remindAt) return;
+      this.state.partialNext({ timeLeftMs: timeLeftMs(this.remindAt.getTime()) });
+    };
+    this.initTimer = () => {
+      this.timer.init();
+    };
+    this.clearTimer = () => {
+      this.timer.clear();
+    };
+    this.state = new StateStore(_Reminder.toStateValue(data));
+    this.timer = new ReminderTimer({ reminder: this, config });
+    this.initTimer();
+  }
+  get id() {
+    return this.state.getLatestValue().message_id;
+  }
+  get remindAt() {
+    return this.state.getLatestValue().remind_at;
+  }
+  get timeLeftMs() {
+    return this.state.getLatestValue().timeLeftMs;
+  }
+};
+_Reminder.toStateValue = (data) => ({
+  ...data,
+  created_at: new Date(data.created_at),
+  message: data.message || null,
+  remind_at: data.remind_at ? new Date(data.remind_at) : null,
+  timeLeftMs: data.remind_at ? timeLeftMs(new Date(data.remind_at).getTime()) : null,
+  updated_at: new Date(data.updated_at),
+  user: data.user || null
+});
+var Reminder = _Reminder;
+
+// src/pagination/BasePaginator.ts
+var DEFAULT_PAGINATION_OPTIONS = {
+  debounceMs: 300,
+  pageSize: 10
+};
+var BasePaginator = class {
+  constructor(options) {
+    this._isCursorPagination = false;
+    this.setDebounceOptions = ({ debounceMs }) => {
+      this._executeQueryDebounced = debounce(this.executeQuery.bind(this), debounceMs);
+    };
+    this.canExecuteQuery = (direction) => !this.isLoading && direction === "next" && this.hasNext || direction === "prev" && this.hasPrev;
+    this.next = () => this.executeQuery({ direction: "next" });
+    this.prev = () => this.executeQuery({ direction: "prev" });
+    this.nextDebounced = () => {
+      this._executeQueryDebounced({ direction: "next" });
+    };
+    this.prevDebounced = () => {
+      this._executeQueryDebounced({ direction: "prev" });
+    };
+    const { debounceMs, pageSize } = { ...DEFAULT_PAGINATION_OPTIONS, ...options };
+    this.pageSize = pageSize;
+    this.state = new StateStore(this.initialState);
+    this.setDebounceOptions({ debounceMs });
+  }
+  get lastQueryError() {
+    return this.state.getLatestValue().lastQueryError;
+  }
+  get hasNext() {
+    return this.state.getLatestValue().hasNext;
+  }
+  get hasPrev() {
+    return this.state.getLatestValue().hasPrev;
+  }
+  get hasResults() {
+    return Array.isArray(this.state.getLatestValue().items);
+  }
+  get isLoading() {
+    return this.state.getLatestValue().isLoading;
+  }
+  get initialState() {
+    return {
+      hasNext: true,
+      hasPrev: true,
+      //todo: check if optimistic value does not cause problems in UI
+      isLoading: false,
+      items: void 0,
+      lastQueryError: void 0,
+      cursor: void 0,
+      offset: 0
+    };
+  }
+  get items() {
+    return this.state.getLatestValue().items;
+  }
+  get cursor() {
+    return this.state.getLatestValue().cursor;
+  }
+  get offset() {
+    return this.state.getLatestValue().offset;
+  }
+  getStateBeforeFirstQuery() {
+    return {
+      ...this.initialState,
+      isLoading: true
+    };
+  }
+  getStateAfterQuery(stateUpdate, isFirstPage) {
+    const current = this.state.getLatestValue();
+    return {
+      ...current,
+      lastQueryError: void 0,
+      // reset lastQueryError that can be overridden by the stateUpdate
+      ...stateUpdate,
+      isLoading: false,
+      items: isFirstPage ? stateUpdate.items : [...this.items ?? [], ...stateUpdate.items || []]
+    };
+  }
+  async executeQuery({ direction }) {
+    if (!this.canExecuteQuery(direction)) return;
+    const isFirstPage = typeof this.items === "undefined";
+    if (isFirstPage) {
+      this.state.next(this.getStateBeforeFirstQuery());
+    } else {
+      this.state.partialNext({ isLoading: true });
+    }
+    const stateUpdate = {};
+    try {
+      const results = await this.query({ direction });
+      if (!results) return;
+      const { items, next, prev } = results;
+      if (isFirstPage && (next || prev)) {
+        this._isCursorPagination = true;
+      }
+      if (this._isCursorPagination) {
+        stateUpdate.cursor = { next: next || null, prev: prev || null };
+        stateUpdate.hasNext = !!next;
+        stateUpdate.hasPrev = !!prev;
+      } else {
+        stateUpdate.offset = (this.offset ?? 0) + items.length;
+        stateUpdate.hasNext = items.length === this.pageSize;
+      }
+      stateUpdate.items = await this.filterQueryResults(items);
+    } catch (e) {
+      stateUpdate.lastQueryError = e;
+    } finally {
+      this.state.next(this.getStateAfterQuery(stateUpdate, isFirstPage));
+    }
+  }
+  cancelScheduledQuery() {
+    this._executeQueryDebounced.cancel();
+  }
+  resetState() {
+    this.state.next(this.initialState);
+  }
+};
+
+// src/pagination/ReminderPaginator.ts
+var ReminderPaginator = class extends BasePaginator {
+  constructor(client, options) {
+    super(options);
+    this.query = async ({
+      direction
+    }) => {
+      const cursor = this.cursor?.[direction];
+      const {
+        reminders: items,
+        next,
+        prev
+      } = await this.client.queryReminders({
+        filter: this.filters,
+        sort: this.sort,
+        limit: this.pageSize,
+        [direction]: cursor
+      });
+      return { items, next, prev };
+    };
+    this.filterQueryResults = (items) => items;
+    this.client = client;
+  }
+};
+
+// src/reminders/ReminderManager.ts
+var oneMinute2 = 60 * 1e3;
+var oneHour2 = 60 * oneMinute2;
+var oneDay2 = 24 * oneHour2;
+var DEFAULT_REMINDER_MANAGER_CONFIG = {
+  scheduledOffsetsMs: [
+    2 * oneMinute2,
+    30 * oneMinute2,
+    oneHour2,
+    2 * oneHour2,
+    8 * oneHour2,
+    oneDay2
+  ]
+};
+var isReminderExistsError = (error) => error.message.match("already has reminder created for this message_id");
+var isReminderDoesNotExistError = (error) => error.message.match("reminder does not exist");
+var _ReminderManager = class _ReminderManager extends WithSubscriptions {
+  constructor({ client, config }) {
+    super();
+    this.upsertToState = ({
+      data,
+      overwrite = true
+    }) => {
+      if (!this.client._cacheEnabled()) {
+        return;
+      }
+      const cachedReminder = this.getFromState(data.message_id);
+      if (!cachedReminder) {
+        const reminder = new Reminder({
+          data,
+          config: { stopRefreshBoundaryMs: this.stopTimerRefreshBoundaryMs }
+        });
+        this.state.partialNext({
+          reminders: new Map(this.reminders.set(data.message_id, reminder))
+        });
+      } else if (overwrite) {
+        cachedReminder.setState(data);
+      }
+      return cachedReminder;
+    };
+    this.removeFromState = (messageId) => {
+      const cachedReminder = this.getFromState(messageId);
+      if (!cachedReminder) return;
+      cachedReminder.clearTimer();
+      const reminders = this.reminders;
+      reminders.delete(messageId);
+      this.state.partialNext({ reminders: new Map(reminders) });
+    };
+    this.hydrateState = (messages) => {
+      messages.forEach(({ reminder }) => {
+        if (reminder) {
+          this.upsertToState({ data: reminder });
+        }
+      });
+    };
+    // State API END //
+    // Timers API START //
+    this.initTimers = () => {
+      this.reminders.forEach((reminder) => reminder.initTimer());
+    };
+    this.clearTimers = () => {
+      this.reminders.forEach((reminder) => reminder.clearTimer());
+    };
+    this.registerSubscriptions = () => {
+      if (this.hasSubscriptions) return;
+      this.addUnsubscribeFunction(this.subscribeReminderCreated());
+      this.addUnsubscribeFunction(this.subscribeReminderUpdated());
+      this.addUnsubscribeFunction(this.subscribeReminderDeleted());
+      this.addUnsubscribeFunction(this.subscribeNotificationReminderDue());
+      this.addUnsubscribeFunction(this.subscribeMessageDeleted());
+      this.addUnsubscribeFunction(this.subscribeMessageUndeleted());
+      this.addUnsubscribeFunction(this.subscribePaginatorStateUpdated());
+      this.addUnsubscribeFunction(this.subscribeConfigStateUpdated());
+    };
+    this.subscribeReminderCreated = () => this.client.on("reminder.created", (event) => {
+      if (!_ReminderManager.isReminderWsEventPayload(event)) return;
+      const { reminder } = event;
+      this.upsertToState({ data: reminder });
+    }).unsubscribe;
+    this.subscribeReminderUpdated = () => this.client.on("reminder.updated", (event) => {
+      if (!_ReminderManager.isReminderWsEventPayload(event)) return;
+      const { reminder } = event;
+      this.upsertToState({ data: reminder });
+    }).unsubscribe;
+    this.subscribeReminderDeleted = () => this.client.on("reminder.deleted", (event) => {
+      if (!_ReminderManager.isReminderWsEventPayload(event)) return;
+      this.removeFromState(event.message_id);
+    }).unsubscribe;
+    this.subscribeMessageDeleted = () => this.client.on("message.deleted", (event) => {
+      if (!event.message?.id) return;
+      this.removeFromState(event.message.id);
+    }).unsubscribe;
+    this.subscribeMessageUndeleted = () => this.client.on("message.undeleted", (event) => {
+      if (!event.message?.reminder) return;
+      this.upsertToState({ data: event.message.reminder });
+    }).unsubscribe;
+    this.subscribeNotificationReminderDue = () => this.client.on("notification.reminder_due", () => null).unsubscribe;
+    // todo: what should be performed on this event?
+    this.subscribePaginatorStateUpdated = () => this.paginator.state.subscribeWithSelector(
+      ({ items }) => [items],
+      ([items]) => {
+        if (!items) return;
+        for (const reminder of items) {
+          this.upsertToState({ data: reminder });
+        }
+      }
+    );
+    this.subscribeConfigStateUpdated = () => this.configState.subscribeWithSelector(
+      ({ stopTimerRefreshBoundaryMs }) => ({ stopTimerRefreshBoundaryMs }),
+      ({ stopTimerRefreshBoundaryMs }, previousValue) => {
+        if (typeof stopTimerRefreshBoundaryMs === "number" && stopTimerRefreshBoundaryMs !== previousValue?.stopTimerRefreshBoundaryMs) {
+          this.reminders.forEach((reminder) => {
+            if (reminder.timer) {
+              reminder.timer.stopRefreshBoundaryMs = stopTimerRefreshBoundaryMs;
+            }
+          });
+        }
+      }
+    );
+    // WS event handling END //
+    // API calls START //
+    this.upsertReminder = async (options) => {
+      const { messageId } = options;
+      if (this.getFromState(messageId)) {
+        try {
+          return await this.updateReminder(options);
+        } catch (error) {
+          if (isReminderDoesNotExistError(error)) {
+            return await this.createReminder(options);
+          }
+          throw error;
+        }
+      } else {
+        try {
+          return await this.createReminder(options);
+        } catch (error) {
+          if (isReminderExistsError(error)) {
+            return await this.updateReminder(options);
+          }
+          throw error;
+        }
+      }
+    };
+    this.createReminder = async (options) => {
+      const { reminder } = await this.client.createReminder(options);
+      return this.upsertToState({ data: reminder, overwrite: false });
+    };
+    this.updateReminder = async (options) => {
+      const { reminder } = await this.client.updateReminder(options);
+      return this.upsertToState({ data: reminder });
+    };
+    this.deleteReminder = async (messageId) => {
+      await this.client.deleteReminder(messageId);
+      this.removeFromState(messageId);
+    };
+    this.queryNextReminders = async () => {
+      await this.paginator.next();
+    };
+    this.queryPreviousReminders = async () => {
+      await this.paginator.prev();
+    };
+    this.client = client;
+    this.configState = new StateStore({
+      scheduledOffsetsMs: config?.scheduledOffsetsMs ?? DEFAULT_REMINDER_MANAGER_CONFIG.scheduledOffsetsMs
+    });
+    this.state = new StateStore({ reminders: /* @__PURE__ */ new Map() });
+    this.paginator = new ReminderPaginator(client);
+  }
+  // Config API START //
+  updateConfig(config) {
+    this.configState.partialNext(config);
+  }
+  get stopTimerRefreshBoundaryMs() {
+    return this.configState.getLatestValue().stopTimerRefreshBoundaryMs;
+  }
+  get scheduledOffsetsMs() {
+    return this.configState.getLatestValue().scheduledOffsetsMs;
+  }
+  // Config API END //
+  // State API START //
+  get reminders() {
+    return this.state.getLatestValue().reminders;
+  }
+  getFromState(messageId) {
+    return this.reminders.get(messageId);
+  }
+  // API calls END //
+};
+// Timers API END //
+// WS event handling START //
+_ReminderManager.isReminderWsEventPayload = (event) => !!event.reminder && (event.type.startsWith("reminder.") || event.type === "notification.reminder_due");
+var ReminderManager = _ReminderManager;
+
 // src/client.ts
 function isString3(x) {
   return typeof x === "string" || x instanceof String;
@@ -12239,6 +12879,9 @@ var StreamChat = class _StreamChat {
     });
     this._getConnectionID = () => this.wsConnection?.connectionID || this.wsFallback?.connectionID;
     this._hasConnectionID = () => Boolean(this._getConnectionID());
+    this.setMessageComposerSetupFunction = (setupFunction) => {
+      this._messageComposerSetupState.partialNext({ setupFunction });
+    };
     /**
      * connectUser - Set the current user and open a WebSocket connection
      *
@@ -12807,9 +13450,6 @@ var StreamChat = class _StreamChat {
       device: this.options.device,
       client_request_id
     });
-    this.setMessageComposerSetupFunction = (setupFunction) => {
-      this._messageComposerSetupState.partialNext({ setupFunction });
-    };
     this.key = key;
     this.listeners = {};
     this.state = new ClientState({ client: this });
@@ -12864,6 +13504,7 @@ var StreamChat = class _StreamChat {
     this.recoverStateOnReconnect = this.options.recoverStateOnReconnect;
     this.threads = new ThreadManager({ client: this });
     this.polls = new PollManager({ client: this });
+    this.reminders = new ReminderManager({ client: this });
   }
   static getInstance(key, secretOrOptions, options) {
     if (!_StreamChat._instance) {
@@ -12999,15 +13640,15 @@ var StreamChat = class _StreamChat {
    * @param {string} userID User ID. If user has no devices, it will error
    * @param {TestPushDataInput} [data] Overrides for push templates/message used
    *  IE: {
-        messageID: 'id-of-message', // will error if message does not exist
-        apnTemplate: '{}', // if app doesn't have apn configured it will error
-        firebaseTemplate: '{}', // if app doesn't have firebase configured it will error
-        firebaseDataTemplate: '{}', // if app doesn't have firebase configured it will error
-        skipDevices: true, // skip config/device checks and sending to real devices
-        pushProviderName: 'staging' // one of your configured push providers
-        pushProviderType: 'apn' // one of supported provider types
-      }
-  */
+   messageID: 'id-of-message', // will error if message does not exist
+   apnTemplate: '{}', // if app doesn't have apn configured it will error
+   firebaseTemplate: '{}', // if app doesn't have firebase configured it will error
+   firebaseDataTemplate: '{}', // if app doesn't have firebase configured it will error
+   skipDevices: true, // skip config/device checks and sending to real devices
+   pushProviderName: 'staging' // one of your configured push providers
+   pushProviderType: 'apn' // one of supported provider types
+   }
+   */
   async testPushSettings(userID, data = {}) {
     return await this.post(this.baseURL + "/check_push", {
       user_id: userID,
@@ -13025,10 +13666,10 @@ var StreamChat = class _StreamChat {
    *
    * @param {TestSQSDataInput} [data] Overrides SQS settings for testing if needed
    *  IE: {
-        sqs_key: 'auth_key',
-        sqs_secret: 'auth_secret',
-        sqs_url: 'url_to_queue',
-      }
+   sqs_key: 'auth_key',
+   sqs_secret: 'auth_secret',
+   sqs_url: 'url_to_queue',
+   }
    */
   async testSQSSettings(data = {}) {
     return await this.post(this.baseURL + "/check_sqs", data);
@@ -13038,10 +13679,10 @@ var StreamChat = class _StreamChat {
    *
    * @param {TestSNSDataInput} [data] Overrides SNS settings for testing if needed
    *  IE: {
-        sns_key: 'auth_key',
-        sns_secret: 'auth_secret',
-        sns_topic_arn: 'topic_to_publish_to',
-      }
+   sns_key: 'auth_key',
+   sns_secret: 'auth_secret',
+   sns_topic_arn: 'topic_to_publish_to',
+   }
    */
   async testSNSSettings(data = {}) {
     return await this.post(this.baseURL + "/check_sns", data);
@@ -13522,6 +14163,7 @@ var StreamChat = class _StreamChat {
           })
         };
         this.polls.hydratePollCache(channelState.messages, true);
+        this.reminders.hydrateState(channelState.messages);
       }
       if (channelState.draft) {
         c.messageComposer.initState({ composition: channelState.draft });
@@ -14442,7 +15084,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.3.0";
+    const version = "9.5.0";
     const clientBundle = "browser-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -15481,6 +16123,56 @@ var StreamChat = class _StreamChat {
     };
     return await this.post(this.baseURL + "/drafts/query", payload);
   }
+  /**
+   * createReminder - Creates a reminder for a message
+   *
+   * @param {CreateReminderOptions} options The options for creating the reminder
+   * @returns {Promise<ReminderAPIResponse>}
+   */
+  async createReminder({ messageId, ...options }) {
+    return await this.post(
+      `${this.baseURL}/messages/${messageId}/reminders`,
+      options
+    );
+  }
+  /**
+   * updateReminder - Updates an existing reminder for a message
+   *
+   * @param {UpdateReminderOptions} options The options for updating the reminder
+   * @returns {Promise<ReminderAPIResponse>}
+   */
+  async updateReminder({ messageId, ...options }) {
+    return await this.patch(
+      `${this.baseURL}/messages/${messageId}/reminders`,
+      options
+    );
+  }
+  /**
+   * deleteReminder - Deletes a reminder for a message
+   *
+   * @param {string} messageId The ID of the message whose reminder to delete
+   * @param {string} [userId] Optional user ID, required for server-side operations
+   * @returns {Promise<APIResponse>}
+   */
+  async deleteReminder(messageId, userId) {
+    return await this.delete(
+      `${this.baseURL}/messages/${messageId}/reminders`,
+      userId ? { user_id: userId } : {}
+    );
+  }
+  /**
+   * queryReminders - Queries reminders based on given filters
+   *
+   * @param {QueryRemindersOptions} options The options for querying reminders
+   * @returns {Promise<QueryRemindersResponse>}
+   */
+  async queryReminders({ filter: filter2, sort, ...rest } = {}) {
+    return await this.post(`${this.baseURL}/reminders/query`, {
+      filter_conditions: filter2,
+      sort: sort && normalizeQuerySort(sort),
+      ...rest
+    });
+  }
 };
 
 // src/events.ts
@@ -15547,7 +16239,12 @@ var EVENT_MAP = {
   "connection.changed": true,
   "connection.recovered": true,
   "transport.changed": true,
-  "capabilities.changed": true
+  "capabilities.changed": true,
+  // Reminder events
+  "reminder.created": true,
+  "reminder.updated": true,
+  "reminder.deleted": true,
+  "notification.reminder_due": true
 };
 
 // src/permissions.ts