dexie-cloud-addon 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.2.0-alpha.4, Fri Aug 01 2025
+ * Version 4.2.0-alpha.6, Fri Aug 01 2025
  *
  * https://dexie.org
  *
@@ -930,7 +930,7 @@
      * @param {Encoder} encoder
      * @return {number}
      */
-    const length$1 = encoder => {
+    const length$2 = encoder => {
       let len = encoder.cpos;
       for (let i = 0; i < encoder.bufs.length; i++) {
         len += encoder.bufs[i].length;
@@ -946,7 +946,7 @@
      * @return {Uint8Array} The created ArrayBuffer.
      */
     const toUint8Array$1 = encoder => {
-      const uint8arr = new Uint8Array(length$1(encoder));
+      const uint8arr = new Uint8Array(length$2(encoder));
       let curPos = 0;
       for (let i = 0; i < encoder.bufs.length; i++) {
         const d = encoder.bufs[i];
@@ -3443,6 +3443,78 @@
         this._observers = create$5();
       }
     }
+
+    /* c8 ignore start */
+    /**
+     * Handles named events.
+     *
+     * @deprecated
+     * @template N
+     */
+    class Observable {
+      constructor () {
+        /**
+         * Some desc.
+         * @type {Map<N, any>}
+         */
+        this._observers = create$5();
+      }
+
+      /**
+       * @param {N} name
+       * @param {function} f
+       */
+      on (name, f) {
+        setIfUndefined(this._observers, name, create$4).add(f);
+      }
+
+      /**
+       * @param {N} name
+       * @param {function} f
+       */
+      once (name, f) {
+        /**
+         * @param  {...any} args
+         */
+        const _f = (...args) => {
+          this.off(name, _f);
+          f(...args);
+        };
+        this.on(name, _f);
+      }
+
+      /**
+       * @param {N} name
+       * @param {function} f
+       */
+      off (name, f) {
+        const observers = this._observers.get(name);
+        if (observers !== undefined) {
+          observers.delete(f);
+          if (observers.size === 0) {
+            this._observers.delete(name);
+          }
+        }
+      }
+
+      /**
+       * Emit a named event. All registered event listeners that listen to the
+       * specified name will receive the event.
+       *
+       * @todo This should catch exceptions
+       *
+       * @param {N} name The event name.
+       * @param {Array<any>} args The arguments that are applied to the event listener.
+       */
+      emit (name, args) {
+        // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
+        return from((this._observers.get(name) || create$5()).values()).forEach(f => f(...args))
+      }
+
+      destroy () {
+        this._observers = create$5();
+      }
+    }
     /* c8 ignore end */
 
     /**
@@ -3639,7 +3711,7 @@
      * @param {Encoder} encoder
      * @return {number}
      */
-    const length = encoder => {
+    const length$1 = encoder => {
       let len = encoder.cpos;
       for (let i = 0; i < encoder.bufs.length; i++) {
         len += encoder.bufs[i].length;
@@ -3655,7 +3727,7 @@
      * @return {Uint8Array} The created ArrayBuffer.
      */
     const toUint8Array = encoder => {
-      const uint8arr = new Uint8Array(length(encoder));
+      const uint8arr = new Uint8Array(length$1(encoder));
       let curPos = 0;
       for (let i = 0; i < encoder.bufs.length; i++) {
         const d = encoder.bufs[i];
@@ -4713,6 +4785,20 @@
       (c ^ uint32() & 15 >> c / 4).toString(16)
     );
 
+    /**
+     * Utility module to work with time.
+     *
+     * @module time
+     */
+
+
+    /**
+     * Return current unix time.
+     *
+     * @return {number}
+     */
+    const getUnixTime = Date.now;
+
     /**
      * Utility helpers to work with promises.
      *
@@ -4839,6 +4925,13 @@
       }
     };
 
+    /**
+     * @deprecated use object.size instead
+     * @param {Object<string,any>} obj
+     * @return {number}
+     */
+    const length = obj => keys(obj).length;
+
     /**
      * @param {Object<string,any>} obj
      * @return {number}
@@ -4935,6 +5028,96 @@
       }
     };
 
+    /**
+     * @template T
+     *
+     * @param {T} a
+     * @param {T} b
+     * @return {boolean}
+     */
+    const equalityStrict = (a, b) => a === b;
+
+    /* c8 ignore start */
+
+    /**
+     * @param {any} a
+     * @param {any} b
+     * @return {boolean}
+     */
+    const equalityDeep = (a, b) => {
+      if (a == null || b == null) {
+        return equalityStrict(a, b)
+      }
+      if (a.constructor !== b.constructor) {
+        return false
+      }
+      if (a === b) {
+        return true
+      }
+      switch (a.constructor) {
+        case ArrayBuffer:
+          a = new Uint8Array(a);
+          b = new Uint8Array(b);
+        // eslint-disable-next-line no-fallthrough
+        case Uint8Array: {
+          if (a.byteLength !== b.byteLength) {
+            return false
+          }
+          for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+              return false
+            }
+          }
+          break
+        }
+        case Set: {
+          if (a.size !== b.size) {
+            return false
+          }
+          for (const value of a) {
+            if (!b.has(value)) {
+              return false
+            }
+          }
+          break
+        }
+        case Map: {
+          if (a.size !== b.size) {
+            return false
+          }
+          for (const key of a.keys()) {
+            if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+              return false
+            }
+          }
+          break
+        }
+        case Object:
+          if (length(a) !== length(b)) {
+            return false
+          }
+          for (const key in a) {
+            if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+              return false
+            }
+          }
+          break
+        case Array:
+          if (a.length !== b.length) {
+            return false
+          }
+          for (let i = 0; i < a.length; i++) {
+            if (!equalityDeep(a[i], b[i])) {
+              return false
+            }
+          }
+          break
+        default:
+          return false
+      }
+      return true
+    };
+
     /**
      * @template V
      * @template {V} OPTS
@@ -13706,7 +13889,7 @@
      *
      * ==========================================================================
      *
-     * Version 4.2.0-alpha.3, Fri Aug 01 2025
+     * Version 4.2.0-alpha.6, Fri Aug 01 2025
      *
      * https://dexie.org
      *
@@ -16189,16 +16372,271 @@
         rxjs.mergeMap((messages) => messages));
     }
 
-    function getAwarenessLibrary(db) {
-        var _a, _b;
-        if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.awarenessProtocol)) {
-            throw new Dexie.MissingAPIError('awarenessProtocol was not provided to db.cloud.configure(). Please import * as awarenessProtocol from "y-protocols/awareness".');
-        }
-        return (_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.awarenessProtocol;
-    }
     const awarenessWeakMap = new WeakMap();
     const getDocAwareness = (doc) => awarenessWeakMap.get(doc);
 
+    /**
+     * @module awareness-protocol
+     */
+
+
+    const outdatedTimeout = 30000;
+
+    /**
+     * @typedef {Object} MetaClientState
+     * @property {number} MetaClientState.clock
+     * @property {number} MetaClientState.lastUpdated unix timestamp
+     */
+
+    /**
+     * The Awareness class implements a simple shared state protocol that can be used for non-persistent data like awareness information
+     * (cursor, username, status, ..). Each client can update its own local state and listen to state changes of
+     * remote clients. Every client may set a state of a remote peer to `null` to mark the client as offline.
+     *
+     * Each client is identified by a unique client id (something we borrow from `doc.clientID`). A client can override
+     * its own state by propagating a message with an increasing timestamp (`clock`). If such a message is received, it is
+     * applied if the known state of that client is older than the new state (`clock < newClock`). If a client thinks that
+     * a remote client is offline, it may propagate a message with
+     * `{ clock: currentClientClock, state: null, client: remoteClient }`. If such a
+     * message is received, and the known clock of that client equals the received clock, it will override the state with `null`.
+     *
+     * Before a client disconnects, it should propagate a `null` state with an updated clock.
+     *
+     * Awareness states must be updated every 30 seconds. Otherwise the Awareness instance will delete the client state.
+     *
+     * @extends {Observable<string>}
+     */
+    class Awareness extends Observable {
+      /**
+       * @param {Y.Doc} doc
+       */
+      constructor (doc) {
+        super();
+        this.doc = doc;
+        /**
+         * @type {number}
+         */
+        this.clientID = doc.clientID;
+        /**
+         * Maps from client id to client state
+         * @type {Map<number, Object<string, any>>}
+         */
+        this.states = new Map();
+        /**
+         * @type {Map<number, MetaClientState>}
+         */
+        this.meta = new Map();
+        this._checkInterval = /** @type {any} */ (setInterval(() => {
+          const now = getUnixTime();
+          if (this.getLocalState() !== null && (outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */ (this.meta.get(this.clientID)).lastUpdated)) {
+            // renew local clock
+            this.setLocalState(this.getLocalState());
+          }
+          /**
+           * @type {Array<number>}
+           */
+          const remove = [];
+          this.meta.forEach((meta, clientid) => {
+            if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {
+              remove.push(clientid);
+            }
+          });
+          if (remove.length > 0) {
+            removeAwarenessStates(this, remove, 'timeout');
+          }
+        }, floor(outdatedTimeout / 10)));
+        doc.on('destroy', () => {
+          this.destroy();
+        });
+        this.setLocalState({});
+      }
+
+      destroy () {
+        this.emit('destroy', [this]);
+        this.setLocalState(null);
+        super.destroy();
+        clearInterval(this._checkInterval);
+      }
+
+      /**
+       * @return {Object<string,any>|null}
+       */
+      getLocalState () {
+        return this.states.get(this.clientID) || null
+      }
+
+      /**
+       * @param {Object<string,any>|null} state
+       */
+      setLocalState (state) {
+        const clientID = this.clientID;
+        const currLocalMeta = this.meta.get(clientID);
+        const clock = currLocalMeta === undefined ? 0 : currLocalMeta.clock + 1;
+        const prevState = this.states.get(clientID);
+        if (state === null) {
+          this.states.delete(clientID);
+        } else {
+          this.states.set(clientID, state);
+        }
+        this.meta.set(clientID, {
+          clock,
+          lastUpdated: getUnixTime()
+        });
+        const added = [];
+        const updated = [];
+        const filteredUpdated = [];
+        const removed = [];
+        if (state === null) {
+          removed.push(clientID);
+        } else if (prevState == null) {
+          if (state != null) {
+            added.push(clientID);
+          }
+        } else {
+          updated.push(clientID);
+          if (!equalityDeep(prevState, state)) {
+            filteredUpdated.push(clientID);
+          }
+        }
+        if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
+          this.emit('change', [{ added, updated: filteredUpdated, removed }, 'local']);
+        }
+        this.emit('update', [{ added, updated, removed }, 'local']);
+      }
+
+      /**
+       * @param {string} field
+       * @param {any} value
+       */
+      setLocalStateField (field, value) {
+        const state = this.getLocalState();
+        if (state !== null) {
+          this.setLocalState({
+            ...state,
+            [field]: value
+          });
+        }
+      }
+
+      /**
+       * @return {Map<number,Object<string,any>>}
+       */
+      getStates () {
+        return this.states
+      }
+    }
+
+    /**
+     * Mark (remote) clients as inactive and remove them from the list of active peers.
+     * This change will be propagated to remote clients.
+     *
+     * @param {Awareness} awareness
+     * @param {Array<number>} clients
+     * @param {any} origin
+     */
+    const removeAwarenessStates = (awareness, clients, origin) => {
+      const removed = [];
+      for (let i = 0; i < clients.length; i++) {
+        const clientID = clients[i];
+        if (awareness.states.has(clientID)) {
+          awareness.states.delete(clientID);
+          if (clientID === awareness.clientID) {
+            const curMeta = /** @type {MetaClientState} */ (awareness.meta.get(clientID));
+            awareness.meta.set(clientID, {
+              clock: curMeta.clock + 1,
+              lastUpdated: getUnixTime()
+            });
+          }
+          removed.push(clientID);
+        }
+      }
+      if (removed.length > 0) {
+        awareness.emit('change', [{ added: [], updated: [], removed }, origin]);
+        awareness.emit('update', [{ added: [], updated: [], removed }, origin]);
+      }
+    };
+
+    /**
+     * @param {Awareness} awareness
+     * @param {Array<number>} clients
+     * @return {Uint8Array}
+     */
+    const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
+      const len = clients.length;
+      const encoder = createEncoder();
+      writeVarUint(encoder, len);
+      for (let i = 0; i < len; i++) {
+        const clientID = clients[i];
+        const state = states.get(clientID) || null;
+        const clock = /** @type {MetaClientState} */ (awareness.meta.get(clientID)).clock;
+        writeVarUint(encoder, clientID);
+        writeVarUint(encoder, clock);
+        writeVarString(encoder, JSON.stringify(state));
+      }
+      return toUint8Array(encoder)
+    };
+
+    /**
+     * @param {Awareness} awareness
+     * @param {Uint8Array} update
+     * @param {any} origin This will be added to the emitted change event
+     */
+    const applyAwarenessUpdate = (awareness, update, origin) => {
+      const decoder = createDecoder(update);
+      const timestamp = getUnixTime();
+      const added = [];
+      const updated = [];
+      const filteredUpdated = [];
+      const removed = [];
+      const len = readVarUint(decoder);
+      for (let i = 0; i < len; i++) {
+        const clientID = readVarUint(decoder);
+        let clock = readVarUint(decoder);
+        const state = JSON.parse(readVarString(decoder));
+        const clientMeta = awareness.meta.get(clientID);
+        const prevState = awareness.states.get(clientID);
+        const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
+        if (currClock < clock || (currClock === clock && state === null && awareness.states.has(clientID))) {
+          if (state === null) {
+            // never let a remote client remove this local state
+            if (clientID === awareness.clientID && awareness.getLocalState() != null) {
+              // remote client removed the local state. Do not remote state. Broadcast a message indicating
+              // that this client still exists by increasing the clock
+              clock++;
+            } else {
+              awareness.states.delete(clientID);
+            }
+          } else {
+            awareness.states.set(clientID, state);
+          }
+          awareness.meta.set(clientID, {
+            clock,
+            lastUpdated: timestamp
+          });
+          if (clientMeta === undefined && state !== null) {
+            added.push(clientID);
+          } else if (clientMeta !== undefined && state === null) {
+            removed.push(clientID);
+          } else if (state !== null) {
+            if (!equalityDeep(state, prevState)) {
+              filteredUpdated.push(clientID);
+            }
+            updated.push(clientID);
+          }
+        }
+      }
+      if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
+        awareness.emit('change', [{
+          added, updated: filteredUpdated, removed
+        }, origin]);
+      }
+      if (added.length > 0 || updated.length > 0 || removed.length > 0) {
+        awareness.emit('update', [{
+          added, updated, removed
+        }, origin]);
+      }
+    };
+
     const wm = new WeakMap();
     /** A property (package-private) on Y.Doc that is used
      * to signal that the server wants us to send a 'doc-open' message
@@ -16394,8 +16832,7 @@
                             if (doc) {
                                 const awareness = getDocAwareness(doc);
                                 if (awareness) {
-                                    const awap = getAwarenessLibrary(this.db);
-                                    awap.applyAwarenessUpdate(awareness, msg.u, 'server');
+                                    applyAwarenessUpdate(awareness, msg.u, 'server');
                                 }
                             }
                         }
@@ -17406,15 +17843,14 @@
     }
     function createAwareness(db, doc, provider) {
         const { parentTable, parentId, parentProp, updatesTable } = doc.meta;
-        const awap = getAwarenessLibrary(db);
-        const awareness = new awap.Awareness(doc);
+        const awareness = new Awareness(doc);
         const reopenDocSignal = getOpenDocSignal(doc);
         awareness.on('update', ({ added, updated, removed }, origin) => {
             // Send the update
             const changedClients = added.concat(updated).concat(removed);
             const user = db.cloud.currentUser.value;
             if (origin !== 'server' && user.isLoggedIn && !isEagerSyncDisabled(db)) {
-                const update = awap.encodeAwarenessUpdate(awareness, changedClients);
+                const update = encodeAwarenessUpdate(awareness, changedClients);
                 db.messageProducer.next({
                     type: 'aware',
                     table: parentTable,
@@ -17440,7 +17876,7 @@
         awareness.on('destroy', () => {
             // Signal to server that this provider is destroyed (the update event will be triggered, which
             // in turn will trigger db.messageProducer that will send the message to the server if WS is connected)
-            awap.removeAwarenessStates(awareness, [doc.clientID], 'provider destroyed');
+            removeAwarenessStates(awareness, [doc.clientID], 'provider destroyed');
         });
         // Open the document on the server
         (() => __awaiter(this, void 0, void 0, function* () {
@@ -17573,7 +18009,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.2.0-alpha.4",
+            version: "4.2.0-alpha.6",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -17890,7 +18326,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.2.0-alpha.4";
+    dexieCloud.version = "4.2.0-alpha.6";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: