@roeehrl/tinode-sdk 0.25.1-sqlite.1

package/src/cbuffer.js

@@ -0,0 +1,244 @@
+/**
+ * @file In-memory sorted cache of objects.
+ *
+ * @copyright 2015-2025 Tinode LLC.
+ */
+'use strict';
+
+/**
+ * In-memory sorted cache of objects.
+ *
+ * @class CBuffer
+ * @memberof Tinode
+ * @protected
+ *
+ * @param {function} compare custom comparator of objects. Takes two parameters <code>a</code> and <code>b</code>;
+ *    returns <code>-1</code> if <code>a < b</code>, <code>0</code> if <code>a == b</code>, <code>1</code> otherwise.
+ * @param {boolean} unique enforce element uniqueness: when <code>true</code> replace existing element with a new
+ *    one on conflict; when <code>false</code> keep both elements.
+ */
+export default class CBuffer {
+  #comparator = undefined;
+  #unique = false;
+  buffer = [];
+
+  constructor(compare_, unique_) {
+    this.#comparator = compare_ || ((a, b) => {
+      return a === b ? 0 : a < b ? -1 : 1;
+    });
+    this.#unique = unique_;
+  }
+
+  #findNearest(elem, arr, exact) {
+    let start = 0;
+    let end = arr.length - 1;
+    let pivot = 0;
+    let diff = 0;
+    let found = false;
+
+    while (start <= end) {
+      pivot = (start + end) / 2 | 0;
+      diff = this.#comparator(arr[pivot], elem);
+      if (diff < 0) {
+        start = pivot + 1;
+      } else if (diff > 0) {
+        end = pivot - 1;
+      } else {
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      return {
+        idx: pivot,
+        exact: true
+      };
+    }
+    if (exact) {
+      return {
+        idx: -1
+      };
+    }
+    // Not exact - insertion point
+    return {
+      idx: diff < 0 ? pivot + 1 : pivot
+    };
+  }
+
+  // Insert element into a sorted array.
+  #insertSorted(elem, arr) {
+    const found = this.#findNearest(elem, arr, false);
+    const count = (found.exact && this.#unique) ? 1 : 0;
+    arr.splice(found.idx, count, elem);
+    return arr;
+  }
+
+  /**
+   * Get an element at the given position.
+   * @memberof Tinode.CBuffer#
+   * @param {number} at - Position to fetch from.
+   * @returns {Object} Element at the given position or <code>undefined</code>.
+   */
+  getAt(at) {
+    return this.buffer[at];
+  }
+
+  /**
+   * Convenience method for getting the last element from the buffer.
+   * @memberof Tinode.CBuffer#
+   * @param {function} filter - optional filter to apply to elements. If filter is provided, the search
+   *   for the last element starts from the end of the buffer and goes backwards until the filter returns true.
+   * @returns {Object} The last element in the buffer or <code>undefined</code> if buffer is empty.
+   */
+  getLast(filter) {
+    return filter ?
+      this.buffer.findLast(filter) :
+      this.buffer[this.buffer.length - 1];
+  }
+
+  /**
+   * Insert new element(s) to the buffer at the correct position according to the sort method.
+   * Variadic: takes one or more arguments. If an array is passed as a single argument, its
+   * elements are inserted individually.
+   * @memberof Tinode.CBuffer#
+   *
+   * @param {...Object|Array} - One or more objects to insert.
+   */
+  put() {
+    let insert;
+    // inspect arguments: if array, insert its elements, if one or more non-array arguments, insert them one by one
+    if (arguments.length == 1 && Array.isArray(arguments[0])) {
+      insert = arguments[0];
+    } else {
+      insert = arguments;
+    }
+    for (let idx in insert) {
+      this.#insertSorted(insert[idx], this.buffer);
+    }
+  }
+
+  /**
+   * Remove element at the given position.
+   * @memberof Tinode.CBuffer#
+   * @param {number} at - Position to delete at.
+   * @returns {Object} Element at the given position or <code>undefined</code>.
+   */
+  delAt(at) {
+    at |= 0;
+    let r = this.buffer.splice(at, 1);
+    if (r && r.length > 0) {
+      return r[0];
+    }
+    return undefined;
+  }
+
+  /**
+   * Remove elements between two positions.
+   * @memberof Tinode.CBuffer#
+   * @param {number} since - Position to delete from (inclusive).
+   * @param {number} before - Position to delete to (exclusive).
+   *
+   * @returns {Array} array of removed elements (could be zero length).
+   */
+  delRange(since, before) {
+    return this.buffer.splice(since, before - since);
+  }
+
+  /**
+   * Return the number of elements the buffer holds.
+   * @memberof Tinode.CBuffer#
+   * @return {number} Number of elements in the buffer.
+   */
+  length() {
+    return this.buffer.length;
+  }
+
+  /**
+   * Reset the buffer discarding all elements
+   * @memberof Tinode.CBuffer#
+   */
+  reset() {
+    this.buffer = [];
+  }
+
+  /**
+   * Callback for iterating contents of buffer. See {@link Tinode.CBuffer#forEach}.
+   * @callback ForEachCallbackType
+   * @memberof Tinode.CBuffer#
+   * @param {Object} elem - Current element of the buffer.
+   * @param {Object} prev - Previous element of the buffer.
+   * @param {Object} next - Next element of the buffer.
+   * @param {number} index - Index of the current element.
+   */
+
+  /**
+   * Apply given <code>callback</code> to all elements of the buffer.
+   * @memberof Tinode.CBuffer#
+   *
+   * @param {Tinode.ForEachCallbackType} callback - Function to call for each element.
+   * @param {number} startIdx - Optional index to start iterating from (inclusive), default: 0.
+   * @param {number} beforeIdx - Optional index to stop iterating before (exclusive), default: length of the buffer.
+   * @param {Object} context - calling context (i.e. value of <code>this</code> in callback)
+   */
+  forEach(callback, startIdx, beforeIdx, context) {
+    startIdx = Math.max(0, startIdx | 0);
+    beforeIdx = Math.min(beforeIdx || this.buffer.length, this.buffer.length);
+
+    for (let i = startIdx; i < beforeIdx; i++) {
+      callback.call(context, this.buffer[i],
+        (i > startIdx ? this.buffer[i - 1] : undefined),
+        (i < beforeIdx - 1 ? this.buffer[i + 1] : undefined), i);
+    }
+  }
+
+  /**
+   * Find element in buffer using buffer's comparison function.
+   * @memberof Tinode.CBuffer#
+   *
+   * @param {Object} elem - element to find.
+   * @param {boolean=} nearest - when true and exact match is not found, return the nearest element (insertion point).
+   * @returns {number} index of the element in the buffer or -1.
+   */
+  find(elem, nearest) {
+    const {
+      idx
+    } = this.#findNearest(elem, this.buffer, !nearest);
+    return idx;
+  }
+
+  /**
+   * Callback for filtering the buffer. See {@link Tinode.CBuffer#filter}.
+   * @callback FilterCallbackType
+   * @memberof Tinode.CBuffer#
+   * @param {Object} elem - Current element of the buffer.
+   * @param {number} index - Index of the current element.
+   * @returns {boolen} <code>true</code> to keep the element, <code>false</code> to remove.
+   */
+
+  /**
+   * Remove all elements that do not pass the test implemented by the provided callback function.
+   * @memberof Tinode.CBuffer#
+   *
+   * @param {Tinode.FilterCallbackType} callback - Function to call for each element.
+   * @param {Object} context - calling context (i.e. value of <code>this</code> in the callback)
+   */
+  filter(callback, context) {
+    let count = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      if (callback.call(context, this.buffer[i], i)) {
+        this.buffer[count] = this.buffer[i];
+        count++;
+      }
+    }
+
+    this.buffer.splice(count);
+  }
+
+  /**
+   * Check if buffer is empty.
+   * @returns {boolean} <code>true</code> if the buffer is empty, <code>false</code> otherwise.
+   */
+  isEmpty() {
+    return this.buffer.length == 0;
+  }
+}

package/src/cbuffer.test.js

@@ -0,0 +1,107 @@
+import CBuffer from './cbuffer';
+
+describe('CBuffer', () => {
+  let buffer;
+
+  beforeEach(() => {
+    buffer = new CBuffer((a, b) => a - b, true);
+  });
+
+  test('should insert elements in sorted order', () => {
+    buffer.put(3, 1, 2);
+    expect(buffer.buffer).toEqual([1, 2, 3]);
+  });
+
+  test('should insert array elements in sorted order', () => {
+    buffer.put([3, 1, 2]);
+    expect(buffer.buffer).toEqual([1, 2, 3]);
+  });
+
+  test('should get element at given position', () => {
+    buffer.put(1, 2, 3);
+    expect(buffer.getAt(1)).toBe(2);
+  });
+
+  test('should get the last element', () => {
+    buffer.put(1, 2, 3);
+    expect(buffer.getLast()).toBe(3);
+  });
+
+  test('should get the last element with filter', () => {
+    buffer.put(1, 2, 3);
+    expect(buffer.getLast(x => x < 3)).toBe(2);
+  });
+
+  test('should delete element at given position', () => {
+    buffer.put(1, 2, 3);
+    expect(buffer.delAt(1)).toBe(2);
+    expect(buffer.buffer).toEqual([1, 3]);
+  });
+
+  test('should delete elements in range', () => {
+    buffer.put(1, 2, 3, 4, 5);
+    expect(buffer.delRange(1, 4)).toEqual([2, 3, 4]);
+    expect(buffer.buffer).toEqual([1, 5]);
+  });
+
+  test('should return the length of the buffer', () => {
+    buffer.put(1, 2, 3);
+    expect(buffer.length()).toBe(3);
+  });
+
+  test('should reset the buffer', () => {
+    buffer.put(1, 2, 3);
+    buffer.reset();
+    expect(buffer.buffer).toEqual([]);
+  });
+
+  test('should iterate over elements with forEach', () => {
+    buffer.put(1, 2, 3);
+    const result = [];
+    buffer.forEach((elem, prev, next, index) => {
+      result.push({
+        elem,
+        prev,
+        next,
+        index
+      });
+    });
+    expect(result).toEqual([{
+        elem: 1,
+        prev: undefined,
+        next: 2,
+        index: 0
+      },
+      {
+        elem: 2,
+        prev: 1,
+        next: 3,
+        index: 1
+      },
+      {
+        elem: 3,
+        prev: 2,
+        next: undefined,
+        index: 2
+      },
+    ]);
+  });
+
+  test('should find element in buffer', () => {
+    buffer.put(1, 2, 3);
+    expect(buffer.find(2)).toBe(1);
+    expect(buffer.find(4)).toBe(-1);
+  });
+
+  test('should filter elements in buffer', () => {
+    buffer.put(1, 2, 3, 4, 5);
+    buffer.filter(x => x % 2 === 0);
+    expect(buffer.buffer).toEqual([2, 4]);
+  });
+
+  test('should check if buffer is empty', () => {
+    expect(buffer.isEmpty()).toBe(true);
+    buffer.put(1);
+    expect(buffer.isEmpty()).toBe(false);
+  });
+});

package/src/comm-error.js

@@ -0,0 +1,14 @@
+/**
+ * @file Throwable error with numeric error code.
+ *
+ * @copyright 2015-2023 Tinode LLC.
+ */
+'use strict';
+
+export default class CommError extends Error {
+  constructor(message, code) {
+    super(`${message} (${code})`);
+    this.name = 'CommError';
+    this.code = code;
+  }
+}

package/src/config.js

@@ -0,0 +1,71 @@
+/**
+ * @file Global constants and configuration parameters.
+ *
+ * @copyright 2015-2025 Tinode LLC
+ */
+'use strict';
+
+import {
+  PACKAGE_VERSION
+} from '../version.js';
+
+// Global constants
+export const PROTOCOL_VERSION = '0'; // Major component of the version, e.g. '0' in '0.17.1'.
+export const VERSION = PACKAGE_VERSION || '0.25';
+export const LIBRARY = 'tinodejs/' + VERSION;
+
+// Topic name prefixes.
+export const TOPIC_NEW = 'new';
+export const TOPIC_NEW_CHAN = 'nch';
+export const TOPIC_ME = 'me';
+export const TOPIC_FND = 'fnd';
+export const TOPIC_SYS = 'sys';
+export const TOPIC_SLF = 'slf';
+export const TOPIC_CHAN = 'chn';
+export const TOPIC_GRP = 'grp';
+export const TOPIC_P2P = 'p2p';
+export const USER_NEW = 'new';
+
+// Starting value of a locally-generated seqId used for pending messages.
+export const LOCAL_SEQID = 0xFFFFFFF;
+
+// Status codes.
+export const MESSAGE_STATUS_NONE = 0; // Status not assigned.
+export const MESSAGE_STATUS_QUEUED = 10; // Local ID assigned, in progress to be sent.
+export const MESSAGE_STATUS_SENDING = 20; // Transmission started.
+export const MESSAGE_STATUS_FAILED = 30; // At least one attempt was made to send the message.
+export const MESSAGE_STATUS_FATAL = 40; // Message sending failed and it should not be retried.
+export const MESSAGE_STATUS_SENT = 50; // Delivered to the server.
+export const MESSAGE_STATUS_RECEIVED = 60; // Received by the client.
+export const MESSAGE_STATUS_READ = 70; // Read by the user.
+export const MESSAGE_STATUS_TO_ME = 80; // The message is received from another user.
+
+// Reject unresolved futures after this many milliseconds.
+export const EXPIRE_PROMISES_TIMEOUT = 5_000;
+// Periodicity of garbage collection of unresolved futures.
+export const EXPIRE_PROMISES_PERIOD = 1_000;
+
+// Delay before acknowledging that a message was recived.
+export const RECV_TIMEOUT = 100;
+
+// Default number of messages to pull into memory from persistent cache.
+export const DEFAULT_MESSAGES_PAGE = 24;
+
+// Unicode DEL character indicating data was deleted.
+export const DEL_CHAR = '\u2421';
+
+// Maximum number of pinnned messages;
+export const MAX_PINNED_COUNT = 5;
+
+// Tag prefixes for alias, email, phone.
+export const TAG_ALIAS = 'alias:';
+export const TAG_EMAIL = 'email:';
+export const TAG_PHONE = 'tel:';
+
+// Parameters of exponential backoff for reconnect attempts.
+// 2000 milliseconds, minimum delay between reconnects.
+export const BACKOFF_BASE = 2_000;
+// Maximum delay between reconnects 2^10 * 2000 ~ 34 minutes.
+export const BACKOFF_MAX_ITER = 10;
+// Random jitter between reconnection attempts, 0.3 -> 30% jitter.
+export const BACKOFF_JITTER = 0.3;