stream-chat 9.29.0 → 9.30.0

package/dist/cjs/index.browser.js

@@ -2132,6 +2132,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;
@@ -2223,11 +2616,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;
@@ -2392,321 +2786,114 @@ var MiddlewareExecutor = class {
   }
 };
 
-// src/messageComposer/middleware/attachmentManager/postUpload/uploadErrorHandler.ts
-var createUploadErrorHandlerMiddleware = (composer) => ({
-  id: "stream-io/attachment-manager-middleware/upload-error",
-  handlers: {
-    postProcess: ({
-      state,
-      discard,
-      forward
-    }) => {
-      const { attachment, error } = state;
-      if (!error) return forward();
-      if (!attachment) return discard();
-      const reason = error instanceof Error ? error.message : "unknown error";
-      composer.client.notifications.addError({
-        message: "Error uploading attachment",
-        origin: {
-          emitter: "AttachmentManager",
-          context: { attachment }
-        },
-        options: {
-          type: "api:attachment:upload:failed",
-          metadata: { reason },
-          originalError: error
-        }
-      });
-      return forward();
-    }
-  }
-});
-
-// src/messageComposer/middleware/attachmentManager/postUpload/AttachmentPostUploadMiddlewareExecutor.ts
-var AttachmentPostUploadMiddlewareExecutor = class extends MiddlewareExecutor {
-  constructor({ composer }) {
-    super();
-    this.use([
-      createUploadErrorHandlerMiddleware(composer),
-      createPostUploadAttachmentEnrichmentMiddleware()
-    ]);
-  }
-};
-
-// src/messageComposer/middleware/attachmentManager/preUpload/serverUploadConfigCheck.ts
-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);
-    };
+// src/messageComposer/middleware/attachmentManager/postUpload/uploadErrorHandler.ts
+var createUploadErrorHandlerMiddleware = (composer) => ({
+  id: "stream-io/attachment-manager-middleware/upload-error",
+  handlers: {
+    postProcess: ({
+      state,
+      discard,
+      forward
+    }) => {
+      const { attachment, error } = state;
+      if (!error) return forward();
+      if (!attachment) return discard();
+      const reason = error instanceof Error ? error.message : "unknown error";
+      composer.client.notifications.addError({
+        message: "Error uploading attachment",
+        origin: {
+          emitter: "AttachmentManager",
+          context: { attachment }
+        },
+        options: {
+          type: "api:attachment:upload:failed",
+          metadata: { reason },
+          originalError: error
+        }
+      });
+      return forward();
+    }
+  }
+});
+
+// src/messageComposer/middleware/attachmentManager/postUpload/AttachmentPostUploadMiddlewareExecutor.ts
+var AttachmentPostUploadMiddlewareExecutor = class extends MiddlewareExecutor {
+  constructor({ composer }) {
+    super();
+    this.use([
+      createUploadErrorHandlerMiddleware(composer),
+      createPostUploadAttachmentEnrichmentMiddleware()
+    ]);
   }
 };
-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`
+
+// src/messageComposer/middleware/attachmentManager/preUpload/serverUploadConfigCheck.ts
+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
       );
-    };
-    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)
+    ]);
   }
 };
 
@@ -3336,11 +3523,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;
@@ -3521,12 +3709,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;
@@ -6342,62 +6528,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 }];
@@ -7984,6 +8114,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
@@ -9119,6 +9250,7 @@ var Channel = class {
     ].sort().join();
     this.data = state.channel;
     this.offlineMode = false;
+    this.cooldownTimer.refresh();
     if (areCapabilitiesChanged) {
       this.getClient().dispatchEvent({
         type: "capabilities.changed",
@@ -9500,6 +9632,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) {
@@ -9634,6 +9769,7 @@ var Channel = class {
             own_capabilities: event.channel?.own_capabilities ?? channel.data?.own_capabilities
           };
           channel.data = newChannelData;
+          this.cooldownTimer.refresh();
         }
         break;
       case "reaction.new":
@@ -9818,6 +9954,7 @@ var Channel = class {
       }
     );
     this.disconnected = true;
+    this.cooldownTimer.clearTimeout();
     this.state.setIsUpToDate(false);
   }
 };
@@ -13954,6 +14091,7 @@ var StreamChat = class _StreamChat {
         this.reminders.hydrateState(channelState.messages);
       }
       c.messageComposer.initStateFromChannelResponse(channelState);
+      c.cooldownTimer.refresh();
       channels.push(c);
     }
     this.syncDeliveredCandidates(channels);
@@ -14949,7 +15087,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.29.0";
+    const version = "9.30.0";
     const clientBundle = "browser-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {