stream-chat 9.28.0 → 9.30.0

package/dist/esm/index.mjs

@@ -1944,6 +1944,399 @@ var ChannelState = class {
   }
 };
 
+// src/store.ts
+var isPatch = (value) => typeof value === "function";
+var noop = () => {
+};
+var StateStore = class {
+  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 = (selector, handler) => {
+      let previouslySelectedValues;
+      const wrappedHandler = (nextValue) => {
+        const newlySelectedValues = selector(nextValue);
+        let hasUpdatedValues = typeof previouslySelectedValues === "undefined";
+        for (const key in previouslySelectedValues) {
+          if (previouslySelectedValues[key] === newlySelectedValues[key]) continue;
+          hasUpdatedValues = true;
+          break;
+        }
+        if (!hasUpdatedValues) 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.
+   */
+  // 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 noop;
+  }
+};
+
+// src/utils/WithSubscriptions.ts
+var _WithSubscriptions = class _WithSubscriptions {
+  constructor() {
+    this.unsubscribeFunctions = /* @__PURE__ */ new Set();
+    this.refCount = 0;
+  }
+  /**
+   * Returns a boolean, provides information of whether `registerSubscriptions`
+   * method has already been called for this instance.
+   */
+  get hasSubscriptions() {
+    return this.unsubscribeFunctions.size > 0;
+  }
+  addUnsubscribeFunction(unsubscribeFunction) {
+    this.unsubscribeFunctions.add(unsubscribeFunction);
+  }
+  /**
+   * Increments `refCount` by one and returns new value.
+   */
+  incrementRefCount() {
+    return ++this.refCount;
+  }
+  /**
+   * If you re-declare `unregisterSubscriptions` method within your class
+   * make sure to run the original too.
+   *
+   * @example
+   * ```ts
+   * class T extends WithSubscriptions {
+   *  ...
+   *  public unregisterSubscriptions = () => {
+   *    this.customThing();
+   *    return super.unregisterSubscriptions();
+   *  }
+   * }
+   * ```
+   */
+  unregisterSubscriptions() {
+    if (this.refCount > 1) {
+      this.refCount--;
+      return _WithSubscriptions.symbol;
+    }
+    this.unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
+    this.unsubscribeFunctions.clear();
+    this.refCount = 0;
+    return _WithSubscriptions.symbol;
+  }
+};
+/**
+ * Workaround for the missing TS keyword - ensures that inheritants
+ * overriding `unregisterSubscriptions` call the base method and return
+ * its unique symbol value.
+ */
+_WithSubscriptions.symbol = Symbol(_WithSubscriptions.name);
+var WithSubscriptions = _WithSubscriptions;
+
+// src/CooldownTimer.ts
+var toDateOrUndefined = (value) => {
+  if (value instanceof Date) return value;
+  if (typeof value === "string" || typeof value === "number") {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) return parsed;
+  }
+  return void 0;
+};
+var CooldownTimer = class extends WithSubscriptions {
+  constructor({ channel }) {
+    super();
+    this.timeout = null;
+    this.registerSubscriptions = () => {
+      this.incrementRefCount();
+      if (this.hasSubscriptions) return;
+      this.addUnsubscribeFunction(
+        this.channel.on("message.new", (event) => {
+          const isOwnMessage = event.message?.user?.id && event.message.user.id === this.getOwnUserId();
+          if (!isOwnMessage) return;
+          this.setOwnLatestMessageDate(toDateOrUndefined(event.message?.created_at));
+        }).unsubscribe
+      );
+      this.addUnsubscribeFunction(
+        this.channel.on("channel.updated", (event) => {
+          const cooldownChanged = event.channel?.cooldown !== this.cooldownConfigSeconds;
+          if (!cooldownChanged) return;
+          this.refresh();
+        }).unsubscribe
+      );
+    };
+    this.setCooldownRemaining = (cooldownRemaining) => {
+      this.state.partialNext({ cooldownRemaining });
+    };
+    this.clearTimeout = () => {
+      if (!this.timeout) return;
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    };
+    this.refresh = () => {
+      const { cooldown: cooldownConfigSeconds = 0, own_capabilities } = this.channel.data ?? {};
+      const canSkipCooldown = (own_capabilities ?? []).includes("skip-slow-mode");
+      const ownLatestMessageDate = this.findOwnLatestMessageDate({
+        messages: this.channel.state.latestMessages
+      });
+      if (cooldownConfigSeconds !== this.cooldownConfigSeconds || ownLatestMessageDate?.getTime() !== this.ownLatestMessageDate?.getTime() || canSkipCooldown !== this.canSkipCooldown) {
+        this.state.partialNext({
+          cooldownConfigSeconds,
+          ownLatestMessageDate,
+          canSkipCooldown
+        });
+      }
+      if (this.canSkipCooldown || this.cooldownConfigSeconds === 0) {
+        this.clearTimeout();
+        if (this.cooldownRemaining !== 0) {
+          this.setCooldownRemaining(0);
+        }
+        return;
+      }
+      this.recalculate();
+    };
+    /**
+     * Updates the known latest own message date and recomputes remaining time.
+     * Prefer calling this when you already know the message date (e.g. from an event).
+     */
+    this.setOwnLatestMessageDate = (date) => {
+      this.state.partialNext({ ownLatestMessageDate: date });
+      this.recalculate();
+    };
+    this.recalculate = () => {
+      this.clearTimeout();
+      const { cooldownConfigSeconds, ownLatestMessageDate, canSkipCooldown } = this.state.getLatestValue();
+      const timeSinceOwnLastMessage = ownLatestMessageDate != null ? (
+        // prevent negative values
+        Math.max(0, (Date.now() - ownLatestMessageDate.getTime()) / 1e3)
+      ) : void 0;
+      const remaining = !canSkipCooldown && typeof timeSinceOwnLastMessage !== "undefined" && cooldownConfigSeconds > timeSinceOwnLastMessage ? Math.round(cooldownConfigSeconds - timeSinceOwnLastMessage) : 0;
+      if (remaining !== this.cooldownRemaining) {
+        this.setCooldownRemaining(remaining);
+      }
+      if (remaining <= 0) return;
+      this.timeout = setTimeout(() => {
+        this.recalculate();
+      }, 1e3);
+    };
+    this.channel = channel;
+    this.state = new StateStore({
+      cooldownConfigSeconds: 0,
+      cooldownRemaining: 0,
+      ownLatestMessageDate: void 0,
+      canSkipCooldown: false
+    });
+    this.refresh();
+  }
+  get cooldownConfigSeconds() {
+    return this.state.getLatestValue().cooldownConfigSeconds;
+  }
+  get cooldownRemaining() {
+    return this.state.getLatestValue().cooldownRemaining;
+  }
+  get canSkipCooldown() {
+    return this.state.getLatestValue().canSkipCooldown;
+  }
+  get ownLatestMessageDate() {
+    return this.state.getLatestValue().ownLatestMessageDate;
+  }
+  getOwnUserId() {
+    const client = this.channel.getClient();
+    return client.userID ?? client.user?.id;
+  }
+  findOwnLatestMessageDate({
+    messages
+  }) {
+    const ownUserId = this.getOwnUserId();
+    if (!ownUserId) return void 0;
+    let latest;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+      const message = messages[i];
+      if (message.user?.id !== ownUserId) continue;
+      const createdAt = toDateOrUndefined(message.created_at);
+      if (!createdAt) continue;
+      if (!latest || createdAt.getTime() > latest.getTime()) {
+        latest = createdAt;
+      }
+      if (latest.getTime() > createdAt.getTime()) break;
+    }
+    return latest;
+  }
+};
+
 // src/messageComposer/attachmentIdentity.ts
 var isScrapedContent = (attachment) => !!attachment?.og_scrape_url || !!attachment?.title_link;
 var isLocalAttachment = (attachment) => !!attachment?.localMetadata?.id;
@@ -2035,11 +2428,12 @@ var createPostUploadAttachmentEnrichmentMiddleware = () => ({
       if (error) return forward();
       if (!attachment || !response) return discard();
       const enrichedAttachment = { ...attachment };
+      const previewUri = attachment.localMetadata.previewUri;
+      if (previewUri) {
+        if (previewUri.startsWith("blob:")) URL.revokeObjectURL(previewUri);
+        delete enrichedAttachment.localMetadata.previewUri;
+      }
       if (isLocalImageAttachment(attachment)) {
-        if (attachment.localMetadata.previewUri) {
-          URL.revokeObjectURL(attachment.localMetadata.previewUri);
-          delete enrichedAttachment.localMetadata.previewUri;
-        }
         enrichedAttachment.image_url = response.file;
       } else {
         enrichedAttachment.asset_url = response.file;
@@ -2250,275 +2644,68 @@ var createUploadConfigCheckMiddleware = (composer) => ({
   id: "stream-io/attachment-manager-middleware/file-upload-config-check",
   handlers: {
     prepare: async ({
-      state,
-      next,
-      discard
-    }) => {
-      const { attachmentManager } = composer;
-      if (!attachmentManager || !state.attachment) return discard();
-      const uploadPermissionCheck = await attachmentManager.getUploadConfigCheck(
-        state.attachment.localMetadata.file
-      );
-      const attachment = {
-        ...state.attachment,
-        localMetadata: {
-          ...state.attachment.localMetadata,
-          uploadPermissionCheck,
-          uploadState: uploadPermissionCheck.uploadBlocked ? "blocked" : "pending"
-        }
-      };
-      return next({
-        ...state,
-        attachment
-      });
-    }
-  }
-});
-
-// src/messageComposer/middleware/attachmentManager/preUpload/blockedUploadNotification.ts
-var createBlockedAttachmentUploadNotificationMiddleware = (composer) => ({
-  id: "stream-io/attachment-manager-middleware/blocked-upload-notification",
-  handlers: {
-    prepare: ({
-      state: { attachment },
-      forward
-    }) => {
-      if (!attachment) return forward();
-      if (attachment.localMetadata.uploadPermissionCheck?.uploadBlocked) {
-        composer.client.notifications.addError({
-          message: `The attachment upload was blocked`,
-          origin: {
-            emitter: "AttachmentManager",
-            context: { blockedAttachment: attachment }
-          },
-          options: {
-            type: "validation:attachment:upload:blocked",
-            metadata: {
-              reason: attachment.localMetadata.uploadPermissionCheck?.reason
-            }
-          }
-        });
-      }
-      return forward();
-    }
-  }
-});
-
-// src/messageComposer/middleware/attachmentManager/preUpload/AttachmentPreUploadMiddlewareExecutor.ts
-var AttachmentPreUploadMiddlewareExecutor = class extends MiddlewareExecutor {
-  constructor({ composer }) {
-    super();
-    this.use([
-      createUploadConfigCheckMiddleware(composer),
-      createBlockedAttachmentUploadNotificationMiddleware(composer)
-    ]);
-  }
-};
-
-// src/store.ts
-var isPatch = (value) => typeof value === "function";
-var noop = () => {
-};
-var StateStore = class {
-  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 = (selector, handler) => {
-      let previouslySelectedValues;
-      const wrappedHandler = (nextValue) => {
-        const newlySelectedValues = selector(nextValue);
-        let hasUpdatedValues = typeof previouslySelectedValues === "undefined";
-        for (const key in previouslySelectedValues) {
-          if (previouslySelectedValues[key] === newlySelectedValues[key]) continue;
-          hasUpdatedValues = true;
-          break;
-        }
-        if (!hasUpdatedValues) 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.
-   */
-  // 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`
+      state,
+      next,
+      discard
+    }) => {
+      const { attachmentManager } = composer;
+      if (!attachmentManager || !state.attachment) return discard();
+      const uploadPermissionCheck = await attachmentManager.getUploadConfigCheck(
+        state.attachment.localMetadata.file
       );
-    };
-    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
-        }));
+      const attachment = {
+        ...state.attachment,
+        localMetadata: {
+          ...state.attachment.localMetadata,
+          uploadPermissionCheck,
+          uploadState: uploadPermissionCheck.uploadBlocked ? "blocked" : "pending"
+        }
       };
-      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);
-        })
-      );
+      return next({
+        ...state,
+        attachment
+      });
     }
-    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;
+});
+
+// src/messageComposer/middleware/attachmentManager/preUpload/blockedUploadNotification.ts
+var createBlockedAttachmentUploadNotificationMiddleware = (composer) => ({
+  id: "stream-io/attachment-manager-middleware/blocked-upload-notification",
+  handlers: {
+    prepare: ({
+      state: { attachment },
+      forward
+    }) => {
+      if (!attachment) return forward();
+      if (attachment.localMetadata.uploadPermissionCheck?.uploadBlocked) {
+        composer.client.notifications.addError({
+          message: `The attachment upload was blocked`,
+          origin: {
+            emitter: "AttachmentManager",
+            context: { blockedAttachment: attachment }
+          },
+          options: {
+            type: "validation:attachment:upload:blocked",
+            metadata: {
+              reason: attachment.localMetadata.uploadPermissionCheck?.reason
+            }
+          }
+        });
       }
+      return forward();
     }
-    return super.getLatestValue();
   }
-  addPreprocessor() {
-    console.warn(
-      `${_MergedStateStore.name}.addPreprocessor is disabled, call original.addPreprocessor or merged.addPreprocessor instead`
-    );
-    return noop;
+});
+
+// src/messageComposer/middleware/attachmentManager/preUpload/AttachmentPreUploadMiddlewareExecutor.ts
+var AttachmentPreUploadMiddlewareExecutor = class extends MiddlewareExecutor {
+  constructor({ composer }) {
+    super();
+    this.use([
+      createUploadConfigCheckMiddleware(composer),
+      createBlockedAttachmentUploadNotificationMiddleware(composer)
+    ]);
   }
 };
 
@@ -3148,11 +3335,12 @@ var _AttachmentManager = class _AttachmentManager {
           uploadState: "finished"
         }
       };
+      const previewUri = uploadedAttachment.localMetadata.previewUri;
+      if (previewUri) {
+        if (previewUri.startsWith("blob:")) URL.revokeObjectURL(previewUri);
+        delete uploadedAttachment.localMetadata.previewUri;
+      }
       if (isLocalImageAttachment(uploadedAttachment)) {
-        if (uploadedAttachment.localMetadata.previewUri) {
-          URL.revokeObjectURL(uploadedAttachment.localMetadata.previewUri);
-          delete uploadedAttachment.localMetadata.previewUri;
-        }
         uploadedAttachment.image_url = response.file;
       } else {
         uploadedAttachment.asset_url = response.file;
@@ -3333,12 +3521,10 @@ _AttachmentManager.toLocalUploadAttachment = (fileLike) => {
     type: getAttachmentTypeFromMimeType(file.type)
   };
   localAttachment[isImageFile(file) ? "fallback" : "title"] = file.name;
-  if (isImageFile(file)) {
-    localAttachment.localMetadata.previewUri = isFileReference(fileLike) ? fileLike.uri : URL.createObjectURL?.(fileLike);
-    if (isFileReference(fileLike) && fileLike.height && fileLike.width) {
-      localAttachment.original_height = fileLike.height;
-      localAttachment.original_width = fileLike.width;
-    }
+  localAttachment.localMetadata.previewUri = isFileReference(fileLike) ? fileLike.uri : URL.createObjectURL?.(fileLike);
+  if (isFileReference(fileLike) && fileLike.height && fileLike.width && isImageFile(file)) {
+    localAttachment.original_height = fileLike.height;
+    localAttachment.original_width = fileLike.width;
   }
   if (isFileReference(fileLike) && fileLike.thumb_url) {
     localAttachment.thumb_url = fileLike.thumb_url;
@@ -5372,10 +5558,11 @@ var getTriggerCharWithToken = ({
   isCommand = false,
   acceptTrailingSpaces = true
 }) => {
-  const triggerNorWhitespace = `[^\\s${trigger}]*`;
+  const escapedTrigger = escapeRegExp(trigger);
+  const triggerNorWhitespace = `[^\\s${escapedTrigger}]*`;
   const match = text.match(
     new RegExp(
-      isCommand ? `^[${trigger}]${triggerNorWhitespace}$` : acceptTrailingSpaces ? `(?!^|\\W)?[${trigger}]${triggerNorWhitespace}\\s?${triggerNorWhitespace}$` : `(?!^|\\W)?[${trigger}]${triggerNorWhitespace}$`,
+      isCommand ? `^[${escapedTrigger}]${triggerNorWhitespace}$` : acceptTrailingSpaces ? `(?!^|\\W)?[${escapedTrigger}]${triggerNorWhitespace}\\s?${triggerNorWhitespace}$` : `(?!^|\\W)?[${escapedTrigger}]${triggerNorWhitespace}$`,
       "g"
     )
   );
@@ -6153,62 +6340,6 @@ var TextComposer = class {
   // --- END TEXT PROCESSING ----
 };
 
-// src/utils/WithSubscriptions.ts
-var _WithSubscriptions = class _WithSubscriptions {
-  constructor() {
-    this.unsubscribeFunctions = /* @__PURE__ */ new Set();
-    this.refCount = 0;
-  }
-  /**
-   * Returns a boolean, provides information of whether `registerSubscriptions`
-   * method has already been called for this instance.
-   */
-  get hasSubscriptions() {
-    return this.unsubscribeFunctions.size > 0;
-  }
-  addUnsubscribeFunction(unsubscribeFunction) {
-    this.unsubscribeFunctions.add(unsubscribeFunction);
-  }
-  /**
-   * Increments `refCount` by one and returns new value.
-   */
-  incrementRefCount() {
-    return ++this.refCount;
-  }
-  /**
-   * If you re-declare `unregisterSubscriptions` method within your class
-   * make sure to run the original too.
-   *
-   * @example
-   * ```ts
-   * class T extends WithSubscriptions {
-   *  ...
-   *  public unregisterSubscriptions = () => {
-   *    this.customThing();
-   *    return super.unregisterSubscriptions();
-   *  }
-   * }
-   * ```
-   */
-  unregisterSubscriptions() {
-    if (this.refCount > 1) {
-      this.refCount--;
-      return _WithSubscriptions.symbol;
-    }
-    this.unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
-    this.unsubscribeFunctions.clear();
-    this.refCount = 0;
-    return _WithSubscriptions.symbol;
-  }
-};
-/**
- * Workaround for the missing TS keyword - ensures that inheritants
- * overriding `unregisterSubscriptions` call the base method and return
- * its unique symbol value.
- */
-_WithSubscriptions.symbol = Symbol(_WithSubscriptions.name);
-var WithSubscriptions = _WithSubscriptions;
-
 // src/thread.ts
 var DEFAULT_PAGE_LIMIT = 50;
 var DEFAULT_SORT = [{ created_at: -1 }];
@@ -7795,6 +7926,7 @@ var Channel = class {
         return msg && { timestampMs, msgId: msg.id };
       }
     });
+    this.cooldownTimer = new CooldownTimer({ channel: this });
   }
   /**
    * getClient - Get the chat client for this channel. If client.disconnect() was called, this function will error
@@ -8930,6 +9062,7 @@ var Channel = class {
     ].sort().join();
     this.data = state.channel;
     this.offlineMode = false;
+    this.cooldownTimer.refresh();
     if (areCapabilitiesChanged) {
       this.getClient().dispatchEvent({
         type: "capabilities.changed",
@@ -9000,11 +9133,13 @@ var Channel = class {
    * unbanUser - Removes the bans for a user on a channel
    *
    * @param {string} targetUserID
+   * @param {UnBanUserOptions} options
    * @returns {Promise<APIResponse>}
    */
-  async unbanUser(targetUserID) {
+  async unbanUser(targetUserID, options) {
     this._checkInitialized();
     return await this.getClient().unbanUser(targetUserID, {
+      ...options,
       type: this.type,
       id: this.id
     });
@@ -9309,6 +9444,9 @@ var Channel = class {
             channelState.addPinnedMessage(event.message);
           }
           const preventUnreadCountUpdate = ownMessage || isThreadMessage;
+          if (ownMessage) {
+            this.cooldownTimer.refresh();
+          }
           if (preventUnreadCountUpdate) break;
           if (event.user?.id) {
             for (const userId in channelState.read) {
@@ -9443,6 +9581,7 @@ var Channel = class {
             own_capabilities: event.channel?.own_capabilities ?? channel.data?.own_capabilities
           };
           channel.data = newChannelData;
+          this.cooldownTimer.refresh();
         }
         break;
       case "reaction.new":
@@ -9627,6 +9766,7 @@ var Channel = class {
       }
     );
     this.disconnected = true;
+    this.cooldownTimer.clearTimeout();
     this.state.setIsUpToDate(false);
   }
 };
@@ -13590,6 +13730,20 @@ var StreamChat = class _StreamChat {
       }
     });
   }
+  /**
+   * queryFutureChannelBans - Query future channel bans created by a user
+   *
+   * @param {QueryFutureChannelBansOptions} options Option object with user_id, exclude_expired_bans, limit, offset
+   * @returns {Promise<FutureChannelBansResponse>} Future Channel Bans Response
+   */
+  async queryFutureChannelBans(options = {}) {
+    return await this.get(
+      this.baseURL + "/query_future_channel_bans",
+      {
+        payload: options
+      }
+    );
+  }
   /**
    * queryMessageFlags - Query message flags
    *
@@ -13609,10 +13763,10 @@ var StreamChat = class _StreamChat {
   /**
    * queryChannelsRequest - Queries channels and returns the raw response
    *
-   * @param {ChannelFilters} filterConditions object MongoDB style filters
+   * @param {ChannelFilters} filterConditions object MongoDB style filters. Can be empty object when using predefined_filter in options.
    * @param {ChannelSort} [sort] Sort options, for instance {created_at: -1}.
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_updated: -1}, {created_at: 1}]
-   * @param {ChannelOptions} [options] Options object
+   * @param {ChannelOptions} [options] Options object. Can include predefined_filter, filter_values, and sort_values for using predefined filters.
    *
    * @return {Promise<Array<ChannelAPIResponse>>} search channels response
    */
@@ -13626,11 +13780,18 @@ var StreamChat = class _StreamChat {
     if (!this._hasConnectionID()) {
       defaultOptions.watch = false;
     }
-    const payload = {
+    const { predefined_filter, filter_values, sort_values, ...restOptions } = options;
+    const payload = predefined_filter ? {
+      predefined_filter,
+      filter_values,
+      sort_values,
+      ...defaultOptions,
+      ...restOptions
+    } : {
       filter_conditions: filterConditions,
       sort: normalizeQuerySort(sort),
       ...defaultOptions,
-      ...options
+      ...restOptions
     };
     const data = await this.post(
       this.baseURL + "/channels",
@@ -13742,6 +13903,7 @@ var StreamChat = class _StreamChat {
         this.reminders.hydrateState(channelState.messages);
       }
       c.messageComposer.initStateFromChannelResponse(channelState);
+      c.cooldownTimer.refresh();
       channels.push(c);
     }
     this.syncDeliveredCandidates(channels);
@@ -14737,7 +14899,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.28.0";
+    const version = "9.30.0";
     const clientBundle = "browser-esm";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -15053,7 +15215,7 @@ var StreamChat = class _StreamChat {
   validateServerSideAuth() {
     if (!this.secret) {
       throw new Error(
-        "Campaigns is a server-side only feature. Please initialize the client with a secret to use this feature."
+        "This feature can be used server-side only. Please initialize the client with a secret to use this feature."
       );
     }
   }
@@ -15918,6 +16080,79 @@ var StreamChat = class _StreamChat {
       payload
     );
   }
+  /**
+   * createPredefinedFilter - Creates a new predefined filter (server-side only)
+   *
+   * @param {CreatePredefinedFilterOptions} options Predefined filter options
+   *
+   * @return {Promise<PredefinedFilterResponse>} The created predefined filter
+   */
+  async createPredefinedFilter(options) {
+    this.validateServerSideAuth();
+    return await this.post(
+      `${this.baseURL}/predefined_filters`,
+      options
+    );
+  }
+  /**
+   * getPredefinedFilter - Gets a predefined filter by name (server-side only)
+   *
+   * @param {string} name Predefined filter name
+   *
+   * @return {Promise<PredefinedFilterResponse>} The predefined filter
+   */
+  async getPredefinedFilter(name) {
+    this.validateServerSideAuth();
+    return await this.get(
+      `${this.baseURL}/predefined_filters/${encodeURIComponent(name)}`
+    );
+  }
+  /**
+   * updatePredefinedFilter - Updates a predefined filter (server-side only)
+   *
+   * @param {string} name Predefined filter name
+   * @param {UpdatePredefinedFilterOptions} options Predefined filter options
+   *
+   * @return {Promise<PredefinedFilterResponse>} The updated predefined filter
+   */
+  async updatePredefinedFilter(name, options) {
+    this.validateServerSideAuth();
+    return await this.put(
+      `${this.baseURL}/predefined_filters/${encodeURIComponent(name)}`,
+      options
+    );
+  }
+  /**
+   * deletePredefinedFilter - Deletes a predefined filter (server-side only)
+   *
+   * @param {string} name Predefined filter name
+   *
+   * @return {Promise<APIResponse>} The server response
+   */
+  async deletePredefinedFilter(name) {
+    this.validateServerSideAuth();
+    return await this.delete(
+      `${this.baseURL}/predefined_filters/${encodeURIComponent(name)}`
+    );
+  }
+  /**
+   * listPredefinedFilters - Lists all predefined filters (server-side only)
+   *
+   * @param {ListPredefinedFiltersOptions} options Query options
+   *
+   * @return {Promise<ListPredefinedFiltersResponse>} The list of predefined filters
+   */
+  async listPredefinedFilters(options = {}) {
+    this.validateServerSideAuth();
+    const { sort, ...paginationOptions } = options;
+    return await this.get(
+      `${this.baseURL}/predefined_filters`,
+      {
+        ...paginationOptions,
+        ...sort ? { sort: JSON.stringify(sort) } : {}
+      }
+    );
+  }
 };
 
 // src/events.ts