stream-chat 9.13.0 → 9.15.0

package/dist/cjs/index.browser.cjs

@@ -140,7 +140,8 @@ var require_https = __commonJS({
 // node_modules/form-data/lib/browser.js
 var require_browser = __commonJS({
   "node_modules/form-data/lib/browser.js"(exports, module2) {
-    module2.exports = typeof self == "object" ? self.FormData : window.FormData;
+    "use strict";
+    module2.exports = typeof self === "object" ? self.FormData : window.FormData;
   }
 });
 
@@ -3151,7 +3152,8 @@ var messagePaginationLinear = ({
   return newPagination;
 };
 var messageSetPagination = (params) => {
-  if (params.parentSet.messages.length < params.returnedPage.length) {
+  const messagesFilteredLocally = params.returnedPage.filter(({ shadowed }) => shadowed);
+  if (params.parentSet.messages.length + messagesFilteredLocally.length < params.returnedPage.length) {
     params.logger?.(
       "error",
       "Corrupted message set state: parent set size < returned page size"
@@ -4088,6 +4090,300 @@ var ensureIsLocalAttachment = (attachment) => {
   };
 };
 
+// src/messageComposer/middleware/attachmentManager/postUpload/attachmentEnrichment.ts
+var createPostUploadAttachmentEnrichmentMiddleware = () => ({
+  id: "stream-io/attachment-manager-middleware/post-upload-enrichment",
+  handlers: {
+    postProcess: ({
+      state,
+      discard,
+      forward,
+      next
+    }) => {
+      const { attachment, error, response } = state;
+      if (error) return forward();
+      if (!attachment || !response) return discard();
+      const enrichedAttachment = { ...attachment };
+      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;
+      }
+      if (response.thumb_url) {
+        enrichedAttachment.thumb_url = response.thumb_url;
+      }
+      return next({
+        ...state,
+        attachment: enrichedAttachment
+      });
+    }
+  }
+});
+
+// src/utils/concurrency.ts
+var withoutConcurrency = createRunner(wrapWithContinuationTracking);
+var withCancellation = createRunner(wrapWithCancellation);
+var pendingPromises = /* @__PURE__ */ new Map();
+function createRunner(wrapper) {
+  return function run(tag, cb) {
+    const { cb: wrapped, onContinued } = wrapper(tag, cb);
+    const pending = pendingPromises.get(tag);
+    pending?.onContinued();
+    const promise = pending ? pending.promise.then(wrapped, wrapped) : wrapped();
+    pendingPromises.set(tag, { promise, onContinued });
+    return promise;
+  };
+}
+function wrapWithContinuationTracking(tag, cb) {
+  let hasContinuation = false;
+  const wrapped = () => cb().finally(() => {
+    if (!hasContinuation) {
+      pendingPromises.delete(tag);
+    }
+  });
+  const onContinued = () => hasContinuation = true;
+  return { cb: wrapped, onContinued };
+}
+function wrapWithCancellation(tag, cb) {
+  const ac = new AbortController();
+  const wrapped = () => {
+    if (ac.signal.aborted) {
+      return Promise.resolve("canceled");
+    }
+    return cb(ac.signal).finally(() => {
+      if (!ac.signal.aborted) {
+        pendingPromises.delete(tag);
+      }
+    });
+  };
+  const onContinued = () => ac.abort();
+  return { cb: wrapped, onContinued };
+}
+
+// src/middleware.ts
+var MiddlewareExecutor = class {
+  constructor() {
+    this.middleware = [];
+    this.id = generateUUIDv4();
+  }
+  use(middleware) {
+    this.middleware = this.middleware.concat(middleware);
+    return this;
+  }
+  // todo: document how to re-arrange the order of middleware using replace
+  replace(middleware) {
+    const newMiddleware = [...this.middleware];
+    middleware.forEach((upserted) => {
+      const existingIndex = this.middleware.findIndex(
+        (existing) => existing.id === upserted.id
+      );
+      if (existingIndex >= 0) {
+        newMiddleware.splice(existingIndex, 1, upserted);
+      } else {
+        newMiddleware.push(upserted);
+      }
+    });
+    this.middleware = newMiddleware;
+    return this;
+  }
+  insert({
+    middleware,
+    position,
+    unique
+  }) {
+    if (unique) {
+      middleware.forEach((md) => {
+        const existingMiddlewareIndex = this.middleware.findIndex((m) => m.id === md.id);
+        if (existingMiddlewareIndex >= 0) {
+          this.middleware.splice(existingMiddlewareIndex, 1);
+        }
+      });
+    }
+    const targetId = position.after || position.before;
+    const targetIndex = this.middleware.findIndex((m) => m.id === targetId);
+    const insertionIndex = position.after ? targetIndex + 1 : targetIndex;
+    this.middleware.splice(insertionIndex, 0, ...middleware);
+    return this;
+  }
+  setOrder(order) {
+    this.middleware = order.map((id) => this.middleware.find((middleware) => middleware.id === id)).filter(Boolean);
+  }
+  remove(middlewareIds) {
+    if (!middlewareIds && !middlewareIds.length) return;
+    this.middleware = this.middleware.filter(
+      (md) => typeof middlewareIds === "string" ? middlewareIds !== md.id : !middlewareIds.includes(md.id)
+    );
+  }
+  async executeMiddlewareChain({
+    eventName,
+    initialValue,
+    mode = "cancelable"
+  }) {
+    let index = -1;
+    const execute = async (i, state, status) => {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      const returnFromChain = i === this.middleware.length || status && ["complete", "discard"].includes(status);
+      if (returnFromChain) return { state, status };
+      const middleware = this.middleware[i];
+      const handler = middleware.handlers[eventName];
+      if (!handler) {
+        return execute(i + 1, state, status);
+      }
+      const next = (adjustedState) => execute(i + 1, adjustedState);
+      const complete = (adjustedState) => execute(i + 1, adjustedState, "complete");
+      const discard = () => execute(i + 1, state, "discard");
+      const forward = () => execute(i + 1, state);
+      return await handler({
+        state,
+        next,
+        complete,
+        discard,
+        forward
+      });
+    };
+    const result = mode === "cancelable" ? await withCancellation(
+      `middleware-execution-${this.id}-${eventName}`,
+      async (abortSignal) => {
+        const result2 = await execute(0, initialValue);
+        if (abortSignal.aborted) {
+          return "canceled";
+        }
+        return result2;
+      }
+    ) : await execute(0, initialValue);
+    return result === "canceled" ? { state: initialValue, status: "discard" } : result;
+  }
+  async execute({
+    eventName,
+    initialValue: initialState,
+    mode
+  }) {
+    return await this.executeMiddlewareChain({
+      eventName,
+      initialValue: initialState,
+      mode
+    });
+  }
+};
+
+// 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 noop2 = () => {
@@ -4679,7 +4975,7 @@ var initState = ({
     };
   })
 });
-var AttachmentManager = class {
+var _AttachmentManager = class _AttachmentManager {
   constructor({ composer, message }) {
     this.setCustomUploadFn = (doUploadRequest) => {
       this.composer.updateConfig({ attachments: { doUploadRequest } });
@@ -4786,42 +5082,18 @@ var AttachmentManager = class {
       }
       return { uploadBlocked: false };
     };
+    // @deprecated use AttachmentManager.toLocalUploadAttachment(file)
     this.fileToLocalUploadAttachment = async (fileLike) => {
-      const file = isFileReference(fileLike) || isFile2(fileLike) ? fileLike : createFileFromBlobs({
-        blobsArray: [fileLike],
-        fileName: generateFileName(fileLike.type),
-        mimeType: fileLike.type
-      });
-      const uploadPermissionCheck = await this.getUploadConfigCheck(file);
-      const localAttachment = {
-        file_size: file.size,
-        mime_type: file.type,
-        localMetadata: {
-          file,
-          id: generateUUIDv4(),
-          uploadPermissionCheck,
-          uploadState: uploadPermissionCheck.uploadBlocked ? "blocked" : "pending"
-        },
-        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;
-        }
-      }
-      if (isFileReference(fileLike) && fileLike.thumb_url) {
-        localAttachment.thumb_url = fileLike.thumb_url;
-      }
-      if (isFileReference(fileLike) && fileLike.duration) {
-        localAttachment.duration = fileLike.duration;
-      }
+      const localAttachment = _AttachmentManager.toLocalUploadAttachment(fileLike);
+      const uploadPermissionCheck = await this.getUploadConfigCheck(
+        localAttachment.localMetadata.file
+      );
+      localAttachment.localMetadata.uploadPermissionCheck = uploadPermissionCheck;
+      localAttachment.localMetadata.uploadState = uploadPermissionCheck.uploadBlocked ? "blocked" : "pending";
       return localAttachment;
     };
     this.ensureLocalUploadAttachment = async (attachment) => {
-      if (!attachment.localMetadata?.file || !attachment.localMetadata.id) {
+      if (!attachment.localMetadata?.file) {
         this.client.notifications.addError({
           message: "File is required for upload attachment",
           origin: { emitter: "AttachmentManager", context: { attachment } },
@@ -4829,6 +5101,14 @@ var AttachmentManager = class {
         });
         return;
       }
+      if (!attachment.localMetadata.id) {
+        this.client.notifications.addError({
+          message: "Local upload attachment missing local id",
+          origin: { emitter: "AttachmentManager", context: { attachment } },
+          options: { type: "validation:attachment:id:missing" }
+        });
+        return;
+      }
       if (!this.fileUploadFilter(attachment)) return;
       const newAttachment = await this.fileToLocalUploadAttachment(
         attachment.localMetadata.file
@@ -4868,6 +5148,7 @@ var AttachmentManager = class {
       }
       return this.doDefaultUploadRequest(fileLike);
     };
+    // @deprecated use attachmentManager.uploadFile(file)
     this.uploadAttachment = async (attachment) => {
       if (!this.isUploadEnabled) return;
       const localAttachment = await this.ensureLocalUploadAttachment(attachment);
@@ -4951,19 +5232,75 @@ var AttachmentManager = class {
       this.updateAttachment(uploadedAttachment);
       return uploadedAttachment;
     };
+    this.uploadFile = async (file) => {
+      const preUpload = await this.preUploadMiddlewareExecutor.execute({
+        eventName: "prepare",
+        initialValue: {
+          attachment: _AttachmentManager.toLocalUploadAttachment(file)
+        },
+        mode: "concurrent"
+      });
+      let attachment = preUpload.state.attachment;
+      if (preUpload.status === "discard") return attachment;
+      if (!this.fileUploadFilter(attachment)) return attachment;
+      if (attachment.localMetadata.uploadState === "blocked") {
+        this.upsertAttachments([attachment]);
+        return preUpload.state.attachment;
+      }
+      attachment = {
+        ...attachment,
+        localMetadata: {
+          ...attachment.localMetadata,
+          uploadState: "uploading"
+        }
+      };
+      this.upsertAttachments([attachment]);
+      let response;
+      let error;
+      try {
+        response = await this.doUploadRequest(file);
+      } catch (err) {
+        error = err instanceof Error ? err : void 0;
+      }
+      const postUpload = await this.postUploadMiddlewareExecutor.execute({
+        eventName: "postProcess",
+        initialValue: {
+          attachment: {
+            ...attachment,
+            localMetadata: {
+              ...attachment.localMetadata,
+              uploadState: error ? "failed" : "finished"
+            }
+          },
+          error,
+          response
+        },
+        mode: "concurrent"
+      });
+      attachment = postUpload.state.attachment;
+      if (postUpload.status === "discard") {
+        this.removeAttachments([attachment.localMetadata.id]);
+        return attachment;
+      }
+      this.updateAttachment(attachment);
+      return attachment;
+    };
     this.uploadFiles = async (files) => {
       if (!this.isUploadEnabled) return;
       const iterableFiles = isFileList2(files) ? Array.from(files) : files;
-      const attachments = await Promise.all(
-        iterableFiles.map(this.fileToLocalUploadAttachment)
-      );
-      return Promise.all(
-        attachments.filter(this.fileUploadFilter).slice(0, this.availableUploadSlots).map(this.uploadAttachment)
+      return await Promise.all(
+        iterableFiles.slice(0, this.availableUploadSlots).map(this.uploadFile)
       );
     };
     this.composer = composer;
     this.state = new StateStore(initState({ message }));
     this.attachmentsByIdGetterCache = { attachmentsById: {}, attachments: [] };
+    this.preUploadMiddlewareExecutor = new AttachmentPreUploadMiddlewareExecutor({
+      composer
+    });
+    this.postUploadMiddlewareExecutor = new AttachmentPostUploadMiddlewareExecutor({
+      composer
+    });
   }
   get attachmentsById() {
     const { attachments } = this.state.getLatestValue();
@@ -4993,9 +5330,15 @@ var AttachmentManager = class {
   set acceptedFiles(acceptedFiles) {
     this.composer.updateConfig({ attachments: { acceptedFiles } });
   }
+  /*
+  @deprecated attachments can be filtered using injecting pre-upload middleware
+   */
   get fileUploadFilter() {
     return this.config.fileUploadFilter;
   }
+  /*
+  @deprecated attachments can be filtered using injecting pre-upload middleware
+   */
   set fileUploadFilter(fileUploadFilter) {
     this.composer.updateConfig({ attachments: { fileUploadFilter } });
   }
@@ -5042,6 +5385,39 @@ var AttachmentManager = class {
     );
   }
 };
+_AttachmentManager.toLocalUploadAttachment = (fileLike) => {
+  const file = isFileReference(fileLike) || isFile2(fileLike) ? fileLike : createFileFromBlobs({
+    blobsArray: [fileLike],
+    fileName: generateFileName(fileLike.type),
+    mimeType: fileLike.type
+  });
+  const localAttachment = {
+    file_size: file.size,
+    mime_type: file.type,
+    localMetadata: {
+      file,
+      id: generateUUIDv4(),
+      uploadState: "pending"
+    },
+    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;
+    }
+  }
+  if (isFileReference(fileLike) && fileLike.thumb_url) {
+    localAttachment.thumb_url = fileLike.thumb_url;
+  }
+  if (isFileReference(fileLike) && fileLike.duration) {
+    localAttachment.duration = fileLike.duration;
+  }
+  return localAttachment;
+};
+var AttachmentManager = _AttachmentManager;
 
 // src/messageComposer/configuration/configuration.ts
 var import_linkifyjs = require("linkifyjs");
@@ -5381,146 +5757,6 @@ var LocationComposer = class {
   }
 };
 
-// src/utils/concurrency.ts
-var withoutConcurrency = createRunner(wrapWithContinuationTracking);
-var withCancellation = createRunner(wrapWithCancellation);
-var pendingPromises = /* @__PURE__ */ new Map();
-function createRunner(wrapper) {
-  return function run(tag, cb) {
-    const { cb: wrapped, onContinued } = wrapper(tag, cb);
-    const pending = pendingPromises.get(tag);
-    pending?.onContinued();
-    const promise = pending ? pending.promise.then(wrapped, wrapped) : wrapped();
-    pendingPromises.set(tag, { promise, onContinued });
-    return promise;
-  };
-}
-function wrapWithContinuationTracking(tag, cb) {
-  let hasContinuation = false;
-  const wrapped = () => cb().finally(() => {
-    if (!hasContinuation) {
-      pendingPromises.delete(tag);
-    }
-  });
-  const onContinued = () => hasContinuation = true;
-  return { cb: wrapped, onContinued };
-}
-function wrapWithCancellation(tag, cb) {
-  const ac = new AbortController();
-  const wrapped = () => {
-    if (ac.signal.aborted) {
-      return Promise.resolve("canceled");
-    }
-    return cb(ac.signal).finally(() => {
-      if (!ac.signal.aborted) {
-        pendingPromises.delete(tag);
-      }
-    });
-  };
-  const onContinued = () => ac.abort();
-  return { cb: wrapped, onContinued };
-}
-
-// src/middleware.ts
-var MiddlewareExecutor = class {
-  constructor() {
-    this.middleware = [];
-    this.id = generateUUIDv4();
-  }
-  use(middleware) {
-    this.middleware = this.middleware.concat(middleware);
-    return this;
-  }
-  // todo: document how to re-arrange the order of middleware using replace
-  replace(middleware) {
-    const newMiddleware = [...this.middleware];
-    middleware.forEach((upserted) => {
-      const existingIndex = this.middleware.findIndex(
-        (existing) => existing.id === upserted.id
-      );
-      if (existingIndex >= 0) {
-        newMiddleware.splice(existingIndex, 1, upserted);
-      } else {
-        newMiddleware.push(upserted);
-      }
-    });
-    this.middleware = newMiddleware;
-    return this;
-  }
-  insert({
-    middleware,
-    position,
-    unique
-  }) {
-    if (unique) {
-      middleware.forEach((md) => {
-        const existingMiddlewareIndex = this.middleware.findIndex((m) => m.id === md.id);
-        if (existingMiddlewareIndex >= 0) {
-          this.middleware.splice(existingMiddlewareIndex, 1);
-        }
-      });
-    }
-    const targetId = position.after || position.before;
-    const targetIndex = this.middleware.findIndex((m) => m.id === targetId);
-    const insertionIndex = position.after ? targetIndex + 1 : targetIndex;
-    this.middleware.splice(insertionIndex, 0, ...middleware);
-    return this;
-  }
-  setOrder(order) {
-    this.middleware = order.map((id) => this.middleware.find((middleware) => middleware.id === id)).filter(Boolean);
-  }
-  async executeMiddlewareChain({
-    eventName,
-    initialValue
-  }) {
-    let index = -1;
-    const execute = async (i, state, status) => {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      const returnFromChain = i === this.middleware.length || status && ["complete", "discard"].includes(status);
-      if (returnFromChain) return { state, status };
-      const middleware = this.middleware[i];
-      const handler = middleware.handlers[eventName];
-      if (!handler) {
-        return execute(i + 1, state, status);
-      }
-      const next = (adjustedState) => execute(i + 1, adjustedState);
-      const complete = (adjustedState) => execute(i + 1, adjustedState, "complete");
-      const discard = () => execute(i + 1, state, "discard");
-      const forward = () => execute(i + 1, state);
-      return await handler({
-        state,
-        next,
-        complete,
-        discard,
-        forward
-      });
-    };
-    const result = await withCancellation(
-      `middleware-execution-${this.id}-${eventName}`,
-      async (abortSignal) => {
-        const result2 = await execute(0, initialValue);
-        if (abortSignal.aborted) {
-          return "canceled";
-        }
-        return result2;
-      }
-    );
-    return result === "canceled" ? { state: initialValue, status: "discard" } : result;
-  }
-  async execute({
-    eventName,
-    initialValue: initialState
-  }) {
-    return await this.executeMiddlewareChain({
-      eventName,
-      initialValue: initialState
-    });
-  }
-};
-
 // src/messageComposer/middleware/pollComposer/state.ts
 var VALID_MAX_VOTES_VALUE_REGEX = /^([2-9]|10)$/;
 var MAX_POLL_OPTIONS = 100;
@@ -8455,7 +8691,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
             id: this.id,
             mentioned_users: [],
             parent_id: this.threadId ?? void 0,
-            pinned_at: null,
+            pinned_at: this.editedMessage?.pinned_at || null,
             reaction_groups: null,
             status: this.editedMessage ? this.editedMessage.status : "sending",
             text,
@@ -12283,15 +12519,17 @@ var Poll = class {
       const { max_votes_allowed, ownVotesByOptionId } = this.data;
       const reachedVoteLimit = max_votes_allowed && max_votes_allowed === Object.keys(ownVotesByOptionId).length;
       if (reachedVoteLimit) {
-        let oldestVote = Object.values(ownVotesByOptionId)[0];
-        Object.values(ownVotesByOptionId).slice(1).forEach((vote) => {
-          if (!oldestVote?.created_at || new Date(vote.created_at) < new Date(oldestVote.created_at)) {
-            oldestVote = vote;
+        this.client.notifications.addInfo({
+          message: "Reached the vote limit. Remove an existing vote first.",
+          origin: {
+            emitter: "Poll",
+            context: { messageId, optionId }
+          },
+          options: {
+            type: "validation:poll:castVote:limit"
           }
         });
-        if (oldestVote?.id) {
-          await this.removeVote(oldestVote.id, messageId);
-        }
+        return;
       }
       return await this.client.castPollVote(messageId, this.id, {
         option_id: optionId
@@ -15774,7 +16012,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.13.0";
+    const version = "9.15.0";
     const clientBundle = "browser-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {