stream-chat 9.2.0 → 9.4.0

package/dist/esm/index.js

@@ -3900,26 +3900,14 @@ var ensureIsLocalAttachment = (attachment) => {
 
 // src/store.ts
 var isPatch = (value) => typeof value === "function";
+var noop2 = () => {
+};
 var StateStore = class {
   constructor(value) {
     this.value = value;
-    this.handlerSet = /* @__PURE__ */ new Set();
-    this.next = (newValueOrPatch) => {
-      const newValue = isPatch(newValueOrPatch) ? newValueOrPatch(this.value) : newValueOrPatch;
-      if (newValue === this.value) return;
-      const oldValue = this.value;
-      this.value = newValue;
-      this.handlerSet.forEach((handler) => handler(this.value, oldValue));
-    };
+    this.handlers = /* @__PURE__ */ new Set();
+    this.preprocessors = /* @__PURE__ */ new Set();
     this.partialNext = (partial) => this.next((current) => ({ ...current, ...partial }));
-    this.getLatestValue = () => this.value;
-    this.subscribe = (handler) => {
-      handler(this.value, void 0);
-      this.handlerSet.add(handler);
-      return () => {
-        this.handlerSet.delete(handler);
-      };
-    };
     this.subscribeWithSelector = (selector, handler) => {
       let previouslySelectedValues;
       const wrappedHandler = (nextValue) => {
@@ -3938,6 +3926,183 @@ var StateStore = class {
       return this.subscribe(wrappedHandler);
     };
   }
+  /**
+   * Allows merging two stores only if their keys differ otherwise there's no way to ensure the data type stability.
+   * @experimental
+   * This method is experimental and may change in future versions.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  merge(stateStore) {
+    return new MergedStateStore({
+      original: this,
+      merged: stateStore
+    });
+  }
+  next(newValueOrPatch) {
+    const newValue = isPatch(newValueOrPatch) ? newValueOrPatch(this.value) : newValueOrPatch;
+    if (newValue === this.value) return;
+    this.preprocessors.forEach((preprocessor) => preprocessor(newValue, this.value));
+    const oldValue = this.value;
+    this.value = newValue;
+    this.handlers.forEach((handler) => handler(this.value, oldValue));
+  }
+  getLatestValue() {
+    return this.value;
+  }
+  subscribe(handler) {
+    handler(this.value, void 0);
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  /**
+   * Registers a preprocessor function that will be called before the state is updated.
+   *
+   * Preprocessors are invoked with the new and previous values whenever `next` or `partialNext` methods
+   * are called, allowing you to mutate or react to the new value before it is set. Preprocessors run in the
+   * order they were registered.
+   *
+   * @example
+   * ```ts
+   * const store = new StateStore<{ count: number; isMaxValue: bool; }>({ count: 0, isMaxValue: false });
+   *
+   * store.addPreprocessor((nextValue, prevValue) => {
+   *   if (nextValue.count > 10) {
+   *     nextValue.count = 10; // Clamp the value to a maximum of 10
+   *   }
+   *
+   *   if (nextValue.count === 10) {
+   *     nextValue.isMaxValue = true; // Set isMaxValue to true if count is 10
+   *   } else {
+   *     nextValue.isMaxValue = false; // Reset isMaxValue otherwise
+   *   }
+   * });
+   *
+   * store.partialNext({ count: 15 });
+   *
+   * store.getLatestValue(); // { count: 10, isMaxValue: true }
+   *
+   * store.partialNext({ count: 5 });
+   *
+   * store.getLatestValue(); // { count: 5, isMaxValue: false }
+   * ```
+   *
+   * @param preprocessor - The function to be called with the next and previous values before the state is updated.
+   * @returns A `RemovePreprocessor` function that removes the preprocessor when called.
+   */
+  addPreprocessor(preprocessor) {
+    this.preprocessors.add(preprocessor);
+    return () => {
+      this.preprocessors.delete(preprocessor);
+    };
+  }
+};
+var MergedStateStore = class _MergedStateStore extends StateStore {
+  constructor({ original, merged }) {
+    const originalValue = original.getLatestValue();
+    const mergedValue = merged.getLatestValue();
+    super({
+      ...originalValue,
+      ...mergedValue
+    });
+    // override original methods and "disable" them
+    this.next = () => {
+      console.warn(
+        `${_MergedStateStore.name}.next is disabled, call original.next or merged.next instead`
+      );
+    };
+    this.partialNext = () => {
+      console.warn(
+        `${_MergedStateStore.name}.partialNext is disabled, call original.partialNext or merged.partialNext instead`
+      );
+    };
+    this.cachedOriginalValue = originalValue;
+    this.cachedMergedValue = mergedValue;
+    this.original = original;
+    this.merged = merged;
+  }
+  /**
+   * Subscribes to changes in the merged state store.
+   *
+   * This method extends the base subscribe functionality to handle the merged nature of this store:
+   * 1. The first subscriber triggers registration of helper subscribers that listen to both source stores
+   * 2. Changes from either source store are propagated to this merged store
+   * 3. Source store values are cached to prevent unnecessary updates
+   *
+   * When the first subscriber is added, the method sets up listeners on both original and merged stores.
+   * These listeners update the combined store value whenever either source store changes.
+   * All subscriptions (helpers and the actual handler) are tracked so they can be properly cleaned up.
+   *
+   * @param handler - The callback function that will be executed when the state changes
+   * @returns An unsubscribe function that, when called, removes the subscription and any helper subscriptions
+   */
+  subscribe(handler) {
+    const unsubscribeFunctions = [];
+    if (!this.handlers.size) {
+      const base = (nextValue) => {
+        super.next((currentValue) => ({
+          ...currentValue,
+          ...nextValue
+        }));
+      };
+      unsubscribeFunctions.push(
+        this.original.subscribe((nextValue) => {
+          if (nextValue === this.cachedOriginalValue) return;
+          this.cachedOriginalValue = nextValue;
+          base(nextValue);
+        }),
+        this.merged.subscribe((nextValue) => {
+          if (nextValue === this.cachedMergedValue) return;
+          this.cachedMergedValue = nextValue;
+          base(nextValue);
+        })
+      );
+    }
+    unsubscribeFunctions.push(super.subscribe(handler));
+    return () => {
+      unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
+    };
+  }
+  /**
+   * Retrieves the latest combined state from both original and merged stores.
+   *
+   * This method extends the base getLatestValue functionality to ensure the merged store
+   * remains in sync with its source stores even when there are no active subscribers.
+   *
+   * When there are no handlers registered, the method:
+   * 1. Fetches the latest values from both source stores
+   * 2. Compares them with the cached values to detect changes
+   * 3. If changes are detected, updates the internal value and caches
+   *    the new source values to maintain consistency
+   *
+   * This approach ensures that calling getLatestValue() always returns the most
+   * up-to-date combined state, even if the merged store hasn't been actively
+   * receiving updates through subscriptions.
+   *
+   * @returns The latest combined state from both original and merged stores
+   */
+  getLatestValue() {
+    if (!this.handlers.size) {
+      const originalValue = this.original.getLatestValue();
+      const mergedValue = this.merged.getLatestValue();
+      if (originalValue !== this.cachedOriginalValue || mergedValue !== this.cachedMergedValue) {
+        this.value = {
+          ...originalValue,
+          ...mergedValue
+        };
+        this.cachedMergedValue = mergedValue;
+        this.cachedOriginalValue = originalValue;
+      }
+    }
+    return super.getLatestValue();
+  }
+  addPreprocessor() {
+    console.warn(
+      `${_MergedStateStore.name}.addPreprocessor is disabled, call original.addPreprocessor or merged.addPreprocessor instead`
+    );
+    return noop2;
+  }
 };
 
 // src/utils/mergeWith/mergeWithCore.ts
@@ -4182,6 +4347,12 @@ function createMergeCore(options = {}) {
       return false;
     }
     function createNewTarget(targetValue, srcValue) {
+      if (targetValue === null || typeof targetValue === "undefined") {
+        return srcValue;
+      }
+      if (!Array.isArray(targetValue) && typeof targetValue !== "object") {
+        return srcValue;
+      }
       if (targetValue && typeof targetValue === "object") {
         const isTargetClassInstance = isClassInstance(targetValue);
         const isSourceClassInstance = isClassInstance(srcValue);
@@ -5283,8 +5454,8 @@ function decodeTlds(encoded) {
 var defaults2 = {
   defaultProtocol: "http",
   events: null,
-  format: noop2,
-  formatHref: noop2,
+  format: noop3,
+  formatHref: noop3,
   nl2br: false,
   tagName: "a",
   target: null,
@@ -5389,7 +5560,7 @@ Options.prototype = {
     return renderFn(ir, token.t, token);
   }
 };
-function noop2(val) {
+function noop3(val) {
   return val;
 }
 function MultiToken(value, tokens) {
@@ -6480,7 +6651,9 @@ var ErrorFromResponse = class extends Error {
     return {
       message: `(${joinable.join(", ")}) - ${this.message}`,
       stack: this.stack,
-      name: this.name
+      name: this.name,
+      code: this.code,
+      status: this.status
     };
   }
 };
@@ -8613,7 +8786,7 @@ var initState5 = (composition) => {
     pollId: message.poll_id ?? null
   };
 };
-var noop3 = () => void 0;
+var noop4 = () => void 0;
 var _MessageComposer = class _MessageComposer extends WithSubscriptions {
   // todo: mediaRecorder: MediaRecorderController;
   constructor({
@@ -8641,7 +8814,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     this.initEditingAuditState = (composition) => initEditingAuditState(composition);
     this.registerSubscriptions = () => {
       if (this.hasSubscriptions) {
-        return noop3;
+        return noop4;
       }
       this.addUnsubscribeFunction(this.subscribeMessageComposerSetupStateChange());
       this.addUnsubscribeFunction(this.subscribeMessageUpdated());
@@ -13894,7 +14067,24 @@ var StreamChat = class _StreamChat {
         'data_template': 'data handlebars template',
         'apn_template': 'apn notification handlebars template under v2'
       },
-      'webhook_url': 'https://acme.com/my/awesome/webhook/'
+      'webhook_url': 'https://acme.com/my/awesome/webhook/',
+      'event_hooks': [
+        {
+          'hook_type': 'webhook',
+          'enabled': true,
+          'event_types': ['message.new'],
+          'webhook_url': 'https://acme.com/my/awesome/webhook/'
+        },
+        {
+          'hook_type': 'sqs',
+          'enabled': true,
+          'event_types': ['message.new'],
+          'sqs_url': 'https://sqs.us-east-1.amazonaws.com/1234567890/my-queue',
+          'sqs_auth_type': 'key',
+          'sqs_key': 'my-access-key',
+          'sqs_secret': 'my-secret-key'
+        }
+      ]
     }
    */
   async updateAppSettings(options) {
@@ -15238,13 +15428,15 @@ var StreamChat = class _StreamChat {
         } else {
           await this.offlineDb.softDeleteMessage({ id: messageID });
         }
-        return await this.offlineDb.queueTask({
-          task: {
-            messageId: messageID,
-            payload: [messageID, hardDelete],
-            type: "delete-message"
+        return await this.offlineDb.queueTask(
+          {
+            task: {
+              messageId: messageID,
+              payload: [messageID, hardDelete],
+              type: "delete-message"
+            }
           }
-        });
+        );
       }
     } catch (error) {
       this.logger("error", `offlineDb:deleteMessage`, {
@@ -15398,7 +15590,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.2.0";
+    const version = "9.4.0";
     const clientBundle = "browser-esm";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -16574,6 +16766,26 @@ var BuiltinPermissions = {
   UseFrozenChannel: "Send messages and reactions to frozen channels"
 };
 
+// src/offline-support/types.ts
+var OfflineError = class extends Error {
+  constructor(message, {
+    type
+  }) {
+    super(message);
+    this.name = "OfflineError";
+    this.type = type;
+  }
+  // Vitest helper (serialized errors are too large to read)
+  // https://github.com/vitest-dev/vitest/blob/v3.1.3/packages/utils/src/error.ts#L60-L62
+  toJSON() {
+    return {
+      message: `${this.type} - ${this.message}`,
+      stack: this.stack,
+      name: this.name
+    };
+  }
+};
+
 // src/offline-support/offline_sync_manager.ts
 var OfflineDBSyncManager = class {
   constructor({
@@ -17179,20 +17391,23 @@ var AbstractOfflineDB = class {
      * @param task - the pending task we want to execute
      */
     this.queueTask = async ({ task }) => {
-      let response;
-      try {
+      const attemptTaskExecution = async () => {
         if (!this.client.wsConnection?.isHealthy) {
-          await this.addPendingTask(task);
-          return;
+          throw new OfflineError(
+            "Cannot execute task because the connection has been lost.",
+            { type: "connection:lost" }
+          );
         }
-        response = await this.executeTask({ task });
+        return await this.executeTask({ task });
+      };
+      try {
+        return await attemptTaskExecution();
       } catch (e) {
         if (!this.shouldSkipQueueingTask(e)) {
           await this.addPendingTask(task);
-          throw e;
         }
+        throw e;
       }
-      return response;
     };
     /**
      * A utility method that determines if a failed task should be added to the
@@ -17385,6 +17600,7 @@ export {
   MODERATION_ENTITY_TYPES,
   MaxPriority,
   MentionsSearchSource,
+  MergedStateStore,
   MessageComposer,
   MessageComposerMiddlewareExecutor,
   MessageDraftComposerMiddlewareExecutor,
@@ -17393,6 +17609,7 @@ export {
   MinPriority,
   Moderation,
   OfflineDBSyncManager,
+  OfflineError,
   Permission,
   Poll,
   PollComposer,