tinybase 5.4.0-beta.1 → 5.4.0-beta.3

package/umd/es6/synchronizers/synchronizer-ws-client/index.js

@@ -11,12 +11,18 @@
 
   const EMPTY_STRING = '';
   const UTF8 = 'utf8';
+  const OPEN = 'open';
+  const MESSAGE = 'message';
+  const ERROR = 'error';
   const UNDEFINED = '\uFFFC';
   const strSplit = (str, separator = EMPTY_STRING, limit) =>
     str.split(separator, limit);
 
   const promise = Promise;
   const GLOBAL = globalThis;
+  const THOUSAND = 1e3;
+  const startTimeout = (callback, sec = 0) =>
+    setTimeout(callback, sec * THOUSAND);
   const math = Math;
   const mathFloor = math.floor;
   const isUndefined = (thing) => thing == void 0;
@@ -94,8 +100,8 @@
       toClientId != null ? toClientId : EMPTY_STRING,
       jsonStringWithUndefined(args),
     );
-  const createRawPayload = (toClientId, remainder) =>
-    toClientId + MESSAGE_SEPARATOR + remainder;
+  const createRawPayload = (clientId, remainder) =>
+    clientId + MESSAGE_SEPARATOR + remainder;
 
   const collSize = (coll) => {
     var _a;
@@ -150,7 +156,7 @@
       },
     );
 
-  const newStamp = (value, time) => (time ? [value, time] : [value]);
+  const stampNew = (value, time) => (time ? [value, time] : [value]);
   const getLatestTime = (time1, time2) => {
     var _a;
     return (
@@ -163,7 +169,7 @@
         : ''
     );
   };
-  const stampNewObj = (time = EMPTY_STRING) => newStamp(objNew(), time);
+  const stampNewObj = (time = EMPTY_STRING) => stampNew(objNew(), time);
 
   const setNew = (entryOrEntries) =>
     new Set(
@@ -332,12 +338,16 @@
   };
   const scheduleRunning = mapNew();
   const scheduleActions = mapNew();
-  const getStoreFunctions = (persist = 1 /* StoreOnly */, store) =>
+  const getStoreFunctions = (
+    persist = 1 /* StoreOnly */,
+    store,
+    isSynchronizer,
+  ) =>
     persist != 1 /* StoreOnly */ && store.isMergeable()
       ? [
           1,
           store.getMergeableContent,
-          store.getTransactionMergeableChanges,
+          () => store.getTransactionMergeableChanges(!isSynchronizer),
           ([[changedTables], [changedValues]]) =>
             !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
           store.setDefaultContent,
@@ -361,6 +371,7 @@
     onIgnoredError,
     persist,
     extra = {},
+    isSynchronizer = 0,
     scheduleId = [],
   ) => {
     let status = 0; /* Idle */
@@ -378,7 +389,7 @@
       getChanges,
       hasChanges,
       setDefaultContent,
-    ] = getStoreFunctions(persist, store);
+    ] = getStoreFunctions(persist, store, isSynchronizer);
     const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
       () => persister,
     );
@@ -433,7 +444,7 @@
                 } else if (initialContent) {
                   setDefaultContent(initialContent);
                 } else {
-                  errorNew(`Content is not an array ${content}`);
+                  errorNew(`Content is not an array: ${content}`);
                 }
               } catch (error) {
                 onIgnoredError == null ? void 0 : onIgnoredError(error);
@@ -449,7 +460,8 @@
       });
     const startAutoLoad = (initialContent) =>
       __async$2(void 0, null, function* () {
-        yield stopAutoLoad().load(initialContent);
+        stopAutoLoad();
+        yield load(initialContent);
         try {
           autoLoadHandle = yield addPersisterListener((content, changes) =>
             __async$2(void 0, null, function* () {
@@ -502,7 +514,8 @@
       });
     const startAutoSave = () =>
       __async$2(void 0, null, function* () {
-        yield stopAutoSave().save();
+        stopAutoSave();
+        yield save();
         autoSaveListenerId = store.addDidFinishTransactionListener(() => {
           const changes = getChanges();
           if (hasChanges(changes)) {
@@ -512,8 +525,10 @@
         return persister;
       });
     const stopAutoSave = () => {
-      ifNotUndefined(autoSaveListenerId, store.delListener);
-      autoSaveListenerId = void 0;
+      if (autoSaveListenerId) {
+        store.delListener(autoSaveListenerId);
+        autoSaveListenerId = void 0;
+      }
       return persister;
     };
     const isAutoSaving = () => !isUndefined(autoSaveListenerId);
@@ -632,41 +647,39 @@
     onIgnoredError,
     extra = {},
   ) => {
+    let syncing = 0;
     let persisterListener;
     let sends = 0;
     let receives = 0;
     const pendingRequests = mapNew();
+    const getTransactionId = () => getUniqueId(11);
     const sendImpl = (toClientId, requestId, message, body) => {
       sends++;
       onSend == null ? void 0 : onSend(toClientId, requestId, message, body);
       send(toClientId, requestId, message, body);
     };
-    const request = (_0, _1, ..._2) =>
-      __async$1(
-        void 0,
-        [_0, _1, ..._2],
-        function* (toClientId, message, body = EMPTY_STRING) {
-          return promiseNew((resolve, reject) => {
-            const requestId = getUniqueId();
-            const timeout = setTimeout(() => {
+    const request = (toClientId, message, body, transactionId) =>
+      __async$1(void 0, null, function* () {
+        return promiseNew((resolve, reject) => {
+          const requestId = transactionId + '.' + getUniqueId(4);
+          const timeout = startTimeout(() => {
+            collDel(pendingRequests, requestId);
+            reject(
+              `No response from ${toClientId != null ? toClientId : 'anyone'} to ${requestId}, ` +
+                message,
+            );
+          }, requestTimeoutSeconds);
+          mapSet(pendingRequests, requestId, [
+            toClientId,
+            (response, fromClientId) => {
+              clearTimeout(timeout);
               collDel(pendingRequests, requestId);
-              reject(
-                `No response from ${toClientId != null ? toClientId : 'anyone'} to ${requestId}, ` +
-                  message,
-              );
-            }, requestTimeoutSeconds * 1e3);
-            mapSet(pendingRequests, requestId, [
-              toClientId,
-              (response, fromClientId) => {
-                clearTimeout(timeout);
-                collDel(pendingRequests, requestId);
-                resolve([response, fromClientId]);
-              },
-            ]);
-            sendImpl(toClientId, requestId, message, body);
-          });
-        },
-      );
+              resolve([response, fromClientId, transactionId]);
+            },
+          ]);
+          sendImpl(toClientId, requestId, message, body);
+        });
+      });
     const mergeTablesStamps = (tablesStamp, [tableStamps2, tablesTime2]) => {
       objForEach(tableStamps2, ([rowStamps2, tableTime2], tableId) => {
         const tableStamp = objEnsure(tablesStamp[0], tableId, stampNewObj);
@@ -675,7 +688,7 @@
           objForEach(
             cellStamps2,
             ([cell2, cellTime2], cellId) =>
-              (rowStamp[0][cellId] = newStamp(cell2, cellTime2)),
+              (rowStamp[0][cellId] = stampNew(cell2, cellTime2)),
           );
           rowStamp[1] = getLatestTime(rowStamp[1], rowTime2);
         });
@@ -683,70 +696,87 @@
       });
       tablesStamp[1] = getLatestTime(tablesStamp[1], tablesTime2);
     };
-    const getChangesFromOtherStore = (
-      otherClientId = null,
-      otherContentHashes,
-    ) =>
-      __async$1(void 0, null, function* () {
-        if (isUndefined(otherContentHashes)) {
-          [otherContentHashes, otherClientId] = yield request(
-            otherClientId,
-            1 /* GetContentHashes */,
-          );
-        }
-        const [otherTablesHash, otherValuesHash] = otherContentHashes;
-        const [tablesHash, valuesHash] = store.getMergeableContentHashes();
-        let tablesChanges = stampNewObj();
-        if (tablesHash != otherTablesHash) {
-          const [newTables, differentTableHashes] = (yield request(
-            otherClientId,
-            4 /* GetTableDiff */,
-            store.getMergeableTableHashes(),
-          ))[0];
-          tablesChanges = newTables;
-          if (!objIsEmpty(differentTableHashes)) {
-            const [newRows, differentRowHashes] = (yield request(
-              otherClientId,
-              5 /* GetRowDiff */,
-              store.getMergeableRowHashes(differentTableHashes),
-            ))[0];
-            mergeTablesStamps(tablesChanges, newRows);
-            if (!objIsEmpty(differentRowHashes)) {
-              const newCells = (yield request(
+    const getChangesFromOtherStore = (..._0) =>
+      __async$1(
+        void 0,
+        [..._0],
+        function* (
+          otherClientId = null,
+          otherContentHashes,
+          transactionId = getTransactionId(),
+        ) {
+          try {
+            if (isUndefined(otherContentHashes)) {
+              [otherContentHashes, otherClientId, transactionId] =
+                yield request(
+                  null,
+                  1 /* GetContentHashes */,
+                  EMPTY_STRING,
+                  transactionId,
+                );
+            }
+            const [otherTablesHash, otherValuesHash] = otherContentHashes;
+            const [tablesHash, valuesHash] = store.getMergeableContentHashes();
+            let tablesChanges = stampNewObj();
+            if (tablesHash != otherTablesHash) {
+              const [newTables, differentTableHashes] = (yield request(
                 otherClientId,
-                6 /* GetCellDiff */,
-                store.getMergeableCellHashes(differentRowHashes),
+                4 /* GetTableDiff */,
+                store.getMergeableTableHashes(),
+                transactionId,
               ))[0];
-              mergeTablesStamps(tablesChanges, newCells);
+              tablesChanges = newTables;
+              if (!objIsEmpty(differentTableHashes)) {
+                const [newRows, differentRowHashes] = (yield request(
+                  otherClientId,
+                  5 /* GetRowDiff */,
+                  store.getMergeableRowHashes(differentTableHashes),
+                  transactionId,
+                ))[0];
+                mergeTablesStamps(tablesChanges, newRows);
+                if (!objIsEmpty(differentRowHashes)) {
+                  const newCells = (yield request(
+                    otherClientId,
+                    6 /* GetCellDiff */,
+                    store.getMergeableCellHashes(differentRowHashes),
+                    transactionId,
+                  ))[0];
+                  mergeTablesStamps(tablesChanges, newCells);
+                }
+              }
             }
+            return [
+              tablesChanges,
+              valuesHash == otherValuesHash
+                ? stampNewObj()
+                : (yield request(
+                    otherClientId,
+                    7 /* GetValueDiff */,
+                    store.getMergeableValueHashes(),
+                    transactionId,
+                  ))[0],
+              1,
+            ];
+          } catch (error) {
+            onIgnoredError == null ? void 0 : onIgnoredError(error);
           }
-        }
-        return [
-          tablesChanges,
-          valuesHash == otherValuesHash
-            ? stampNewObj()
-            : (yield request(
-                otherClientId,
-                7 /* GetValueDiff */,
-                store.getMergeableValueHashes(),
-              ))[0],
-          1,
-        ];
-      });
+        },
+      );
     const getPersisted = () =>
       __async$1(void 0, null, function* () {
         const changes = yield getChangesFromOtherStore();
-        return !objIsEmpty(changes[0][0]) || !objIsEmpty(changes[1][0])
+        return changes &&
+          (!objIsEmpty(changes[0][0]) || !objIsEmpty(changes[1][0]))
           ? changes
           : void 0;
       });
     const setPersisted = (_getContent, changes) =>
       __async$1(void 0, null, function* () {
         return changes
-          ? sendImpl(null, null, 3 /* ContentDiff */, changes)
+          ? sendImpl(null, getTransactionId(), 3 /* ContentDiff */, changes)
           : sendImpl(
               null,
-              null,
+              getTransactionId(),
               2 /* ContentHashes */,
               store.getMergeableContentHashes(),
             );
@@ -755,11 +785,15 @@
     const delPersisterListener = () => (persisterListener = void 0);
     const startSync = (initialContent) =>
       __async$1(void 0, null, function* () {
+        syncing = 1;
         return yield (yield persister.startAutoLoad(
           initialContent,
         )).startAutoSave();
       });
-    const stopSync = () => persister.stopAutoLoad().stopAutoSave();
+    const stopSync = () => {
+      syncing = 0;
+      return persister.stopAutoLoad().stopAutoSave();
+    };
     const destroy = () => {
       destroyImpl();
       return persister.stopSync();
@@ -778,35 +812,41 @@
         {startSync, stopSync, destroy, getSynchronizerStats},
         extra,
       ),
+      1,
     );
-    registerReceive((fromClientId, requestId, message, body) => {
+    registerReceive((fromClientId, transactionOrRequestId, message, body) => {
+      const isAutoLoading = syncing || persister.isAutoLoading();
       receives++;
       onReceive == null
         ? void 0
-        : onReceive(fromClientId, requestId, message, body);
+        : onReceive(fromClientId, transactionOrRequestId, message, body);
       if (message == 0 /* Response */) {
         ifNotUndefined(
-          mapGet(pendingRequests, requestId),
+          mapGet(pendingRequests, transactionOrRequestId),
           ([toClientId, handleResponse]) =>
             isUndefined(toClientId) || toClientId == fromClientId
               ? handleResponse(body, fromClientId)
               : /* istanbul ignore next */
                 0,
         );
-      } else if (
-        message == 2 /* ContentHashes */ &&
-        persister.isAutoLoading()
-      ) {
-        getChangesFromOtherStore(fromClientId, body).then((changes) => {
-          persisterListener == null
-            ? void 0
-            : persisterListener(void 0, changes);
-        });
-      } else if (message == 3 /* ContentDiff */ && persister.isAutoLoading()) {
+      } else if (message == 2 /* ContentHashes */ && isAutoLoading) {
+        getChangesFromOtherStore(
+          fromClientId,
+          body,
+          transactionOrRequestId != null ? transactionOrRequestId : void 0,
+        )
+          .then((changes) => {
+            persisterListener == null
+              ? void 0
+              : persisterListener(void 0, changes);
+          })
+          .catch(onIgnoredError);
+      } else if (message == 3 /* ContentDiff */ && isAutoLoading) {
         persisterListener == null ? void 0 : persisterListener(void 0, body);
       } else {
         ifNotUndefined(
-          message == 1 /* GetContentHashes */ && persister.isAutoSaving()
+          message == 1 /* GetContentHashes */ &&
+            (syncing || persister.isAutoSaving())
             ? store.getMergeableContentHashes()
             : message == 4 /* GetTableDiff */
               ? store.getMergeableTableDiff(body)
@@ -818,7 +858,12 @@
                     ? store.getMergeableValueDiff(body)
                     : void 0,
           (response) => {
-            sendImpl(fromClientId, requestId, 0 /* Response */, response);
+            sendImpl(
+              fromClientId,
+              transactionOrRequestId,
+              0 /* Response */,
+              response,
+            );
           },
         );
       }
@@ -858,10 +903,12 @@
     onIgnoredError,
   ) =>
     __async(void 0, null, function* () {
-      const addEventListener = (event, handler) =>
+      const addEventListener = (event, handler) => {
         webSocket.addEventListener(event, handler);
+        return () => webSocket.removeEventListener(event, handler);
+      };
       const registerReceive = (receive) =>
-        addEventListener('message', ({data}) =>
+        addEventListener(MESSAGE, ({data}) =>
           receivePayload(data.toString(UTF8), receive),
         );
       const send = (toClientId, ...args) =>
@@ -880,10 +927,18 @@
         onIgnoredError,
         {getWebSocket: () => webSocket},
       );
-      return promiseNew((resolve, reject) => {
+      return promiseNew((resolve) => {
         if (webSocket.readyState != webSocket.OPEN) {
-          addEventListener('error', reject);
-          addEventListener('open', () => resolve(synchronizer));
+          const onAttempt = (error) => {
+            if (error) {
+              onIgnoredError == null ? void 0 : onIgnoredError(error);
+            }
+            removeOpenListener();
+            removeErrorListener();
+            resolve(synchronizer);
+          };
+          const removeOpenListener = addEventListener(OPEN, () => onAttempt());
+          const removeErrorListener = addEventListener(ERROR, onAttempt);
         } else {
           resolve(synchronizer);
         }