stream-chat 9.3.0 → 9.4.0

package/dist/cjs/index.node.cjs

@@ -9631,7 +9631,7 @@ var require_common = __commonJS({
         createDebug.namespaces = namespaces;
         createDebug.names = [];
         createDebug.skips = [];
-        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
         for (const ns of split) {
           if (ns[0] === "-") {
             createDebug.skips.push(ns.slice(1));
@@ -9849,7 +9849,7 @@ var require_browser = __commonJS({
     function load() {
       let r;
       try {
-        r = exports2.storage.getItem("debug");
+        r = exports2.storage.getItem("debug") || exports2.storage.getItem("DEBUG");
       } catch (error) {
       }
       if (!r && typeof process !== "undefined" && "env" in process) {
@@ -10233,7 +10233,7 @@ var require_follow_redirects = __commonJS({
       "ERR_STREAM_WRITE_AFTER_END",
       "write after end"
     );
-    var destroy = Writable.prototype.destroy || noop3;
+    var destroy = Writable.prototype.destroy || noop4;
     function RedirectableRequest(options, responseCallback) {
       Writable.call(this);
       this._sanitizeOptions(options);
@@ -10585,7 +10585,7 @@ var require_follow_redirects = __commonJS({
       });
       return exports3;
     }
-    function noop3() {
+    function noop4() {
     }
     function urlToOptions(urlObject) {
       var options = {
@@ -10631,7 +10631,7 @@ var require_follow_redirects = __commonJS({
       for (var event of events) {
         request.removeListener(event, eventHandlers[event]);
       }
-      request.on("error", noop3);
+      request.on("error", noop4);
       request.destroy(error);
     }
     function isSubdomain(subdomain, domain) {
@@ -10703,6 +10703,7 @@ __export(index_exports, {
   MODERATION_ENTITY_TYPES: () => MODERATION_ENTITY_TYPES,
   MaxPriority: () => MaxPriority,
   MentionsSearchSource: () => MentionsSearchSource,
+  MergedStateStore: () => MergedStateStore,
   MessageComposer: () => MessageComposer,
   MessageComposerMiddlewareExecutor: () => MessageComposerMiddlewareExecutor,
   MessageDraftComposerMiddlewareExecutor: () => MessageDraftComposerMiddlewareExecutor,
@@ -15391,26 +15392,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) => {
@@ -15429,6 +15418,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
@@ -16848,7 +17014,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
     };
   }
 };
@@ -18981,7 +19149,7 @@ var initState5 = (composition) => {
     pollId: message.poll_id ?? null
   };
 };
-var noop2 = () => void 0;
+var noop3 = () => void 0;
 var _MessageComposer = class _MessageComposer extends WithSubscriptions {
   // todo: mediaRecorder: MediaRecorderController;
   constructor({
@@ -19009,7 +19177,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     this.initEditingAuditState = (composition) => initEditingAuditState(composition);
     this.registerSubscriptions = () => {
       if (this.hasSubscriptions) {
-        return noop2;
+        return noop3;
       }
       this.addUnsubscribeFunction(this.subscribeMessageComposerSetupStateChange());
       this.addUnsubscribeFunction(this.subscribeMessageUpdated());
@@ -25773,7 +25941,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.3.0";
+    const version = "9.4.0";
     const clientBundle = "node-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -27784,6 +27952,7 @@ var FixedSizeQueueCache = class {
   MODERATION_ENTITY_TYPES,
   MaxPriority,
   MentionsSearchSource,
+  MergedStateStore,
   MessageComposer,
   MessageComposerMiddlewareExecutor,
   MessageDraftComposerMiddlewareExecutor,