stream-chat 8.38.0 → 8.40.0

package/src/utils.ts

@@ -3,12 +3,15 @@ import {
   AscDesc,
   ExtendableGenerics,
   DefaultGenerics,
+  Logger,
   OwnUserBase,
   OwnUserResponse,
   UserResponse,
   MessageResponse,
   FormatMessageResponse,
   ReactionGroupResponse,
+  MessageSet,
+  MessagePaginationOptions,
 } from './types';
 import { AxiosRequestConfig } from 'axios';
 
@@ -277,14 +280,13 @@ export const axiosParamsSerializer: AxiosRequestConfig['paramsSerializer'] = (pa
 };
 
 /**
- * formatMessage - Takes the message object. Parses the dates, sets __html
- * and sets the status to received if missing. Returns a message object
- *
- * @param {MessageResponse<StreamChatGenerics>} message a message object
+ * Takes the message object, parses the dates, sets `__html`
+ * and sets the status to `received` if missing; returns a new message object.
  *
+ * @param {MessageResponse<StreamChatGenerics>} message `MessageResponse` object
  */
 export function formatMessage<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>(
-  message: MessageResponse<StreamChatGenerics>,
+  message: MessageResponse<StreamChatGenerics> | FormatMessageResponse<StreamChatGenerics>,
 ): FormatMessageResponse<StreamChatGenerics> {
   return {
     ...message,
@@ -292,10 +294,11 @@ export function formatMessage<StreamChatGenerics extends ExtendableGenerics = De
      * @deprecated please use `html`
      */
     __html: message.html,
-    // parse the date..
+    // parse the dates
     pinned_at: message.pinned_at ? new Date(message.pinned_at) : null,
     created_at: message.created_at ? new Date(message.created_at) : new Date(),
     updated_at: message.updated_at ? new Date(message.updated_at) : new Date(),
+    deleted_at: message.deleted_at ? new Date(message.deleted_at) : null,
     status: message.status || 'received',
     reaction_groups: maybeGetReactionGroupsFallback(
       message.reaction_groups,
@@ -305,71 +308,124 @@ export function formatMessage<StreamChatGenerics extends ExtendableGenerics = De
   };
 }
 
-export function addToMessageList<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>(
-  messages: Array<FormatMessageResponse<StreamChatGenerics>>,
-  message: FormatMessageResponse<StreamChatGenerics>,
+export const findIndexInSortedArray = <T, L>({
+  needle,
+  sortedArray,
+  selectValueToCompare = (e) => e,
+  sortDirection = 'ascending',
+}: {
+  needle: T;
+  sortedArray: readonly T[];
+  /**
+   * In array of objects (like messages), pick a specific
+   * property to compare needle value to.
+   *
+   * @example
+   * ```ts
+   * selectValueToCompare: (message) => message.created_at.getTime()
+   * ```
+   */
+  selectValueToCompare?: (arrayElement: T) => L | T;
+  /**
+   * @default ascending
+   * @description
+   * ```md
+   * ascending  - [1,2,3,4,5...]
+   * descending - [...5,4,3,2,1]
+   * ```
+   */
+  sortDirection?: 'ascending' | 'descending';
+}) => {
+  if (!sortedArray.length) return 0;
+
+  let left = 0;
+  let right = sortedArray.length - 1;
+  let middle = 0;
+
+  const recalculateMiddle = () => {
+    middle = Math.round((left + right) / 2);
+  };
+
+  const actualNeedle = selectValueToCompare(needle);
+  recalculateMiddle();
+
+  while (left <= right) {
+    // if (actualNeedle === selectValueToCompare(sortedArray[middle])) return middle;
+
+    if (
+      (sortDirection === 'ascending' && actualNeedle < selectValueToCompare(sortedArray[middle])) ||
+      (sortDirection === 'descending' && actualNeedle > selectValueToCompare(sortedArray[middle]))
+    ) {
+      right = middle - 1;
+    } else {
+      left = middle + 1;
+    }
+
+    recalculateMiddle();
+  }
+
+  return left;
+};
+
+export function addToMessageList<T extends FormatMessageResponse>(
+  messages: readonly T[],
+  newMessage: T,
   timestampChanged = false,
   sortBy: 'pinned_at' | 'created_at' = 'created_at',
   addIfDoesNotExist = true,
 ) {
   const addMessageToList = addIfDoesNotExist || timestampChanged;
-  let messageArr = messages;
+  let newMessages = [...messages];
 
   // if created_at has changed, message should be filtered and re-inserted in correct order
   // slow op but usually this only happens for a message inserted to state before actual response with correct timestamp
   if (timestampChanged) {
-    messageArr = messageArr.filter((msg) => !(msg.id && message.id === msg.id));
+    newMessages = newMessages.filter((message) => !(message.id && newMessage.id === message.id));
   }
 
-  // Get array length after filtering
-  const messageArrayLength = messageArr.length;
-
   // for empty list just concat and return unless it's an update or deletion
-  if (messageArrayLength === 0 && addMessageToList) {
-    return messageArr.concat(message);
-  } else if (messageArrayLength === 0) {
-    return [...messageArr];
+  if (!newMessages.length && addMessageToList) {
+    return newMessages.concat(newMessage);
   }
 
-  const messageTime = (message[sortBy] as Date).getTime();
-  const messageIsNewest = (messageArr[messageArrayLength - 1][sortBy] as Date).getTime() < messageTime;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const messageTime = newMessage[sortBy]!.getTime();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const messageIsNewest = newMessages.at(-1)![sortBy]!.getTime() < messageTime;
 
   // if message is newer than last item in the list concat and return unless it's an update or deletion
   if (messageIsNewest && addMessageToList) {
-    return messageArr.concat(message);
-  } else if (messageIsNewest) {
-    return [...messageArr];
+    return newMessages.concat(newMessage);
   }
 
   // find the closest index to push the new message
-  let left = 0;
-  let middle = 0;
-  let right = messageArrayLength - 1;
-  while (left <= right) {
-    middle = Math.floor((right + left) / 2);
-    if ((messageArr[middle][sortBy] as Date).getTime() <= messageTime) left = middle + 1;
-    else right = middle - 1;
-  }
+  const insertionIndex = findIndexInSortedArray({
+    needle: newMessage,
+    sortedArray: messages,
+    sortDirection: 'ascending',
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    selectValueToCompare: (m) => m[sortBy]!.getTime(),
+  });
 
-  // message already exists and not filtered due to timestampChanged, update and return
-  if (!timestampChanged && message.id) {
-    if (messageArr[left] && message.id === messageArr[left].id) {
-      messageArr[left] = message;
-      return [...messageArr];
+  // message already exists and not filtered with timestampChanged, update and return
+  if (!timestampChanged && newMessage.id) {
+    if (newMessages[insertionIndex] && newMessage.id === newMessages[insertionIndex].id) {
+      newMessages[insertionIndex] = newMessage;
+      return newMessages;
     }
 
-    if (messageArr[left - 1] && message.id === messageArr[left - 1].id) {
-      messageArr[left - 1] = message;
-      return [...messageArr];
+    if (newMessages[insertionIndex - 1] && newMessage.id === newMessages[insertionIndex - 1].id) {
+      newMessages[insertionIndex - 1] = newMessage;
+      return newMessages;
     }
   }
 
-  // Do not add updated or deleted messages to the list if they do not already exist
-  // or have a timestamp change.
+  // do not add updated or deleted messages to the list if they already exist or come with a timestamp change
   if (addMessageToList) {
-    messageArr.splice(left, 0, message);
+    newMessages.splice(insertionIndex, 0, newMessage);
   }
-  return [...messageArr];
+
+  return newMessages;
 }
 
 function maybeGetReactionGroupsFallback(
@@ -396,3 +452,266 @@ function maybeGetReactionGroupsFallback(
 
   return null;
 }
+
+// works exactly the same as lodash.throttle
+export const throttle = <T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  timeout = 200,
+  { leading = true, trailing = false }: { leading?: boolean; trailing?: boolean } = {},
+) => {
+  let runningTimeout: null | NodeJS.Timeout = null;
+  let storedArgs: Parameters<T> | null = null;
+
+  return (...args: Parameters<T>) => {
+    if (runningTimeout) {
+      if (trailing) storedArgs = args;
+      return;
+    }
+
+    if (leading) fn(...args);
+
+    const timeoutHandler = () => {
+      if (storedArgs) {
+        fn(...storedArgs);
+        storedArgs = null;
+        runningTimeout = setTimeout(timeoutHandler, timeout);
+
+        return;
+      }
+
+      runningTimeout = null;
+    };
+
+    runningTimeout = setTimeout(timeoutHandler, timeout);
+  };
+};
+
+type MessagePaginationUpdatedParams<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  parentSet: MessageSet;
+  requestedPageSize: number;
+  returnedPage: MessageResponse<StreamChatGenerics>[];
+  logger?: Logger;
+  messagePaginationOptions?: MessagePaginationOptions;
+};
+
+export function binarySearchByDateEqualOrNearestGreater(
+  array: {
+    created_at?: string;
+  }[],
+  targetDate: Date,
+): number {
+  let left = 0;
+  let right = array.length - 1;
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const midCreatedAt = array[mid].created_at;
+    if (!midCreatedAt) {
+      left += 1;
+      continue;
+    }
+    const midDate = new Date(midCreatedAt);
+
+    if (midDate.getTime() === targetDate.getTime()) {
+      return mid;
+    } else if (midDate.getTime() < targetDate.getTime()) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+
+  return left;
+}
+
+const messagePaginationCreatedAtAround = <StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>({
+  parentSet,
+  requestedPageSize,
+  returnedPage,
+  messagePaginationOptions,
+}: MessagePaginationUpdatedParams<StreamChatGenerics>) => {
+  const newPagination = { ...parentSet.pagination };
+  if (!messagePaginationOptions?.created_at_around) return newPagination;
+  let hasPrev;
+  let hasNext;
+  let updateHasPrev;
+  let updateHasNext;
+  const createdAtAroundDate = new Date(messagePaginationOptions.created_at_around);
+  const [firstPageMsg, lastPageMsg] = [returnedPage[0], returnedPage.slice(-1)[0]];
+
+  // expect ASC order (from oldest to newest)
+  const wholePageHasNewerMessages =
+    !!firstPageMsg?.created_at && new Date(firstPageMsg.created_at) > createdAtAroundDate;
+  const wholePageHasOlderMessages = !!lastPageMsg?.created_at && new Date(lastPageMsg.created_at) < createdAtAroundDate;
+
+  const requestedPageSizeNotMet =
+    requestedPageSize > parentSet.messages.length && requestedPageSize > returnedPage.length;
+  const noMoreMessages =
+    (requestedPageSize > parentSet.messages.length || parentSet.messages.length >= returnedPage.length) &&
+    requestedPageSize > returnedPage.length;
+
+  if (wholePageHasNewerMessages) {
+    hasPrev = false;
+    updateHasPrev = true;
+    if (requestedPageSizeNotMet) {
+      hasNext = false;
+      updateHasNext = true;
+    }
+  } else if (wholePageHasOlderMessages) {
+    hasNext = false;
+    updateHasNext = true;
+    if (requestedPageSizeNotMet) {
+      hasPrev = false;
+      updateHasPrev = true;
+    }
+  } else if (noMoreMessages) {
+    hasNext = hasPrev = false;
+    updateHasPrev = updateHasNext = true;
+  } else {
+    const [firstPageMsgIsFirstInSet, lastPageMsgIsLastInSet] = [
+      firstPageMsg?.id && firstPageMsg.id === parentSet.messages[0]?.id,
+      lastPageMsg?.id && lastPageMsg.id === parentSet.messages.slice(-1)[0]?.id,
+    ];
+    updateHasPrev = firstPageMsgIsFirstInSet;
+    updateHasNext = lastPageMsgIsLastInSet;
+    const midPointByCount = Math.floor(returnedPage.length / 2);
+    const midPointByCreationDate = binarySearchByDateEqualOrNearestGreater(returnedPage, createdAtAroundDate);
+
+    if (midPointByCreationDate !== -1) {
+      hasPrev = midPointByCount <= midPointByCreationDate;
+      hasNext = midPointByCount >= midPointByCreationDate;
+    }
+  }
+
+  if (updateHasPrev && typeof hasPrev !== 'undefined') newPagination.hasPrev = hasPrev;
+  if (updateHasNext && typeof hasNext !== 'undefined') newPagination.hasNext = hasNext;
+
+  return newPagination;
+};
+
+const messagePaginationIdAround = <StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>({
+  parentSet,
+  requestedPageSize,
+  returnedPage,
+  messagePaginationOptions,
+}: MessagePaginationUpdatedParams<StreamChatGenerics>) => {
+  const newPagination = { ...parentSet.pagination };
+  const { id_around } = messagePaginationOptions || {};
+  if (!id_around) return newPagination;
+  let hasPrev;
+  let hasNext;
+
+  const [firstPageMsg, lastPageMsg] = [returnedPage[0], returnedPage.slice(-1)[0]];
+  const [firstPageMsgIsFirstInSet, lastPageMsgIsLastInSet] = [
+    firstPageMsg?.id === parentSet.messages[0]?.id,
+    lastPageMsg?.id === parentSet.messages.slice(-1)[0]?.id,
+  ];
+  let updateHasPrev = firstPageMsgIsFirstInSet;
+  let updateHasNext = lastPageMsgIsLastInSet;
+
+  const midPoint = Math.floor(returnedPage.length / 2);
+  const noMoreMessages =
+    (requestedPageSize > parentSet.messages.length || parentSet.messages.length >= returnedPage.length) &&
+    requestedPageSize > returnedPage.length;
+
+  if (noMoreMessages) {
+    hasNext = hasPrev = false;
+    updateHasPrev = updateHasNext = true;
+  } else if (!returnedPage[midPoint]) {
+    return newPagination;
+  } else if (returnedPage[midPoint].id === id_around) {
+    hasPrev = hasNext = true;
+  } else {
+    let targetMsg;
+    const halves = [returnedPage.slice(0, midPoint), returnedPage.slice(midPoint)];
+    hasPrev = hasNext = true;
+    for (let i = 0; i < halves.length; i++) {
+      targetMsg = halves[i].find((message) => message.id === id_around);
+      if (targetMsg && i === 0) {
+        hasPrev = false;
+      }
+      if (targetMsg && i === 1) {
+        hasNext = false;
+      }
+    }
+  }
+
+  if (updateHasPrev && typeof hasPrev !== 'undefined') newPagination.hasPrev = hasPrev;
+  if (updateHasNext && typeof hasNext !== 'undefined') newPagination.hasNext = hasNext;
+
+  return newPagination;
+};
+
+const messagePaginationLinear = <StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>({
+  parentSet,
+  requestedPageSize,
+  returnedPage,
+  messagePaginationOptions,
+}: MessagePaginationUpdatedParams<StreamChatGenerics>) => {
+  const newPagination = { ...parentSet.pagination };
+
+  let hasPrev;
+  let hasNext;
+
+  const [firstPageMsg, lastPageMsg] = [returnedPage[0], returnedPage.slice(-1)[0]];
+  const [firstPageMsgIsFirstInSet, lastPageMsgIsLastInSet] = [
+    firstPageMsg?.id && firstPageMsg.id === parentSet.messages[0]?.id,
+    lastPageMsg?.id && lastPageMsg.id === parentSet.messages.slice(-1)[0]?.id,
+  ];
+
+  const queriedNextMessages =
+    messagePaginationOptions &&
+    (messagePaginationOptions.created_at_after_or_equal ||
+      messagePaginationOptions.created_at_after ||
+      messagePaginationOptions.id_gt ||
+      messagePaginationOptions.id_gte);
+
+  const queriedPrevMessages =
+    typeof messagePaginationOptions === 'undefined'
+      ? true
+      : messagePaginationOptions.created_at_before_or_equal ||
+        messagePaginationOptions.created_at_before ||
+        messagePaginationOptions.id_lt ||
+        messagePaginationOptions.id_lte ||
+        messagePaginationOptions.offset;
+
+  const containsUnrecognizedOptionsOnly =
+    !queriedNextMessages &&
+    !queriedPrevMessages &&
+    !messagePaginationOptions?.id_around &&
+    !messagePaginationOptions?.created_at_around;
+
+  const hasMore = returnedPage.length >= requestedPageSize;
+
+  if (typeof queriedPrevMessages !== 'undefined' || containsUnrecognizedOptionsOnly) {
+    hasPrev = hasMore;
+  }
+  if (typeof queriedNextMessages !== 'undefined') {
+    hasNext = hasMore;
+  }
+  const returnedPageIsEmpty = returnedPage.length === 0;
+
+  if ((firstPageMsgIsFirstInSet || returnedPageIsEmpty) && typeof hasPrev !== 'undefined')
+    newPagination.hasPrev = hasPrev;
+  if ((lastPageMsgIsLastInSet || returnedPageIsEmpty) && typeof hasNext !== 'undefined')
+    newPagination.hasNext = hasNext;
+
+  return newPagination;
+};
+
+export const messageSetPagination = <StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>(
+  params: MessagePaginationUpdatedParams<StreamChatGenerics>,
+) => {
+  if (params.parentSet.messages.length < params.returnedPage.length) {
+    params.logger?.('error', 'Corrupted message set state: parent set size < returned page size');
+    return params.parentSet.pagination;
+  }
+
+  if (params.messagePaginationOptions?.created_at_around) {
+    return messagePaginationCreatedAtAround(params);
+  } else if (params.messagePaginationOptions?.id_around) {
+    return messagePaginationIdAround(params);
+  } else {
+    return messagePaginationLinear(params);
+  }
+};