tinybase 5.0.0-beta.1 → 5.0.0-beta.11

package/lib/debug/metrics.js

@@ -52,9 +52,11 @@ const mapForEach = (map, cb) =>
   collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-automerge.js

@@ -3,6 +3,7 @@ const TINYBASE = 'tinybase';
 const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
   isUndefined(value) ? otherwise?.() : then(value);
+const isArray = (thing) => Array.isArray(thing);
 const size = (arrayOrString) => arrayOrString.length;
 
 const arrayMap = (array, cb) => array.map(cb);
@@ -12,8 +13,6 @@ const arrayShift = (array) => array.shift();
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objEntries = object.entries;
-const objIds = object.keys;
-const objFreeze = object.freeze;
 const isObject = (obj) =>
   !isUndefined(obj) &&
   ifNotUndefined(
@@ -24,13 +23,15 @@ const isObject = (obj) =>
     /* istanbul ignore next */
     () => true,
   );
+const objIds = object.keys;
+const objFreeze = object.freeze;
 const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
   delete obj[id];
   return obj;
 };
-const objMap = (obj, cb) =>
+const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
@@ -48,15 +49,38 @@ const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };
 
 const scheduleRunning = mapNew();
 const scheduleActions = mapNew();
+const getStoreFunctions = (supportedStoreType = 1, store) =>
+  supportedStoreType > 1 && 'getMergeableContent' in store
+    ? [
+        1,
+        store.getMergeableContent,
+        store.getTransactionMergeableChanges,
+        ([[changedTables], [changedValues]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+        store.setDefaultContent,
+      ]
+    : supportedStoreType != 2
+      ? [
+          0,
+          store.getContent,
+          store.getTransactionChanges,
+          ([changedTables, changedValues]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setContent,
+        ]
+      : /* istanbul ignore next */
+        0;
 const createCustomPersister = (
   store,
   getPersisted,
@@ -64,18 +88,25 @@ const createCustomPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
-  [getThing, thing] = [],
+  supportedStoreType,
+  extra = {},
   scheduleId = [],
 ) => {
-  let listenerId;
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
-  let listening = 0;
   let action;
-  let listeningHandle;
+  let autoLoadHandle;
+  let autoSaveListenerId;
   mapEnsure(scheduleRunning, scheduleId, () => 0);
   mapEnsure(scheduleActions, scheduleId, () => []);
+  const [
+    isMergeableStore,
+    getContent,
+    getChanges,
+    hasChanges,
+    setDefaultContent,
+  ] = getStoreFunctions(supportedStoreType, store);
   const run = async () => {
     /* istanbul ignore else */
     if (!mapGet(scheduleRunning, scheduleId)) {
@@ -93,109 +124,121 @@ const createCustomPersister = (
       mapSet(scheduleRunning, scheduleId, 0);
     }
   };
-  const loadLock = async (actions) => {
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isArray(contentOrChanges?.[0])
+      ? contentOrChanges?.[2] === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : contentOrChanges?.[2] === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
+  const load = async (initialContent) => {
     /* istanbul ignore else */
     if (loadSave != 2) {
       loadSave = 1;
       {
         loads++;
       }
-      await persister.schedule(async () => {
-        await actions();
+      await schedule(async () => {
+        try {
+          setContentOrChanges(await getPersisted());
+        } catch (error) {
+          onIgnoredError?.(error);
+          if (initialContent) {
+            setDefaultContent(initialContent);
+          }
+        }
         loadSave = 0;
       });
     }
     return persister;
   };
-  const persister = {
-    load: async (initialTables, initialValues) =>
-      await loadLock(async () => {
-        try {
-          store.setContent(await getPersisted());
-        } catch {
-          store.setContent([initialTables, initialValues]);
-        }
-      }),
-    startAutoLoad: async (initialTables = {}, initialValues = {}) => {
-      persister.stopAutoLoad();
-      await persister.load(initialTables, initialValues);
-      listening = 1;
-      listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
-          if (getTransactionChanges) {
-            const transactionChanges = getTransactionChanges();
-            await loadLock(async () =>
-              store.setTransactionChanges(transactionChanges),
-            );
-          } else {
-            await loadLock(async () => {
-              try {
-                store.setContent(getContent?.() ?? (await getPersisted()));
-              } catch (error) {
-                onIgnoredError?.(error);
-              }
-            });
+  const startAutoLoad = async (initialContent) => {
+    await stopAutoLoad().load(initialContent);
+    autoLoadHandle = addPersisterListener(async (content, changes) => {
+      if (changes || content) {
+        /* istanbul ignore else */
+        if (loadSave != 2) {
+          loadSave = 1;
+          {
+            loads++;
           }
-        },
-      );
-      return persister;
-    },
-    stopAutoLoad: () => {
-      if (listening) {
-        delPersisterListener(listeningHandle);
-        listeningHandle = void 0;
-        listening = 0;
+          setContentOrChanges(changes ?? content);
+          loadSave = 0;
+        }
+      } else {
+        await load();
+      }
+    });
+    return persister;
+  };
+  const stopAutoLoad = () => {
+    if (autoLoadHandle) {
+      delPersisterListener(autoLoadHandle);
+      autoLoadHandle = void 0;
+    }
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = async (changes) => {
+    /* istanbul ignore else */
+    if (loadSave != 1) {
+      loadSave = 2;
+      {
+        saves++;
       }
-      return persister;
-    },
-    save: async (getTransactionChanges) => {
-      /* istanbul ignore else */
-      if (loadSave != 1) {
-        loadSave = 2;
-        {
-          saves++;
+      await schedule(async () => {
+        try {
+          await setPersisted(getContent, changes);
+        } catch (error) {
+          /* istanbul ignore next */
+          onIgnoredError?.(error);
         }
-        await persister.schedule(async () => {
-          try {
-            await setPersisted(store.getContent, getTransactionChanges);
-          } catch (error) {
-            /* istanbul ignore next */
-            onIgnoredError?.(error);
-          }
-          loadSave = 0;
-        });
+        loadSave = 0;
+      });
+    }
+    return persister;
+  };
+  const startAutoSave = async () => {
+    await stopAutoSave().save();
+    autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+      const changes = getChanges();
+      if (hasChanges(changes)) {
+        save(changes);
       }
-      return persister;
-    },
-    startAutoSave: async () => {
-      await persister.stopAutoSave().save();
-      listenerId = store.addDidFinishTransactionListener(
-        (_store, getTransactionChanges) => {
-          const [tableChanges, valueChanges] = getTransactionChanges();
-          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
-            persister.save(() => [tableChanges, valueChanges]);
-          }
-        },
-      );
-      return persister;
-    },
-    stopAutoSave: () => {
-      ifNotUndefined(listenerId, store.delListener);
-      listenerId = void 0;
-      return persister;
-    },
-    schedule: async (...actions) => {
-      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-      await run();
-      return persister;
-    },
-    getStore: () => store,
-    destroy: () => persister.stopAutoLoad().stopAutoSave(),
-    getStats: () => ({loads, saves}),
+    });
+    return persister;
+  };
+  const stopAutoSave = () => {
+    ifNotUndefined(autoSaveListenerId, store.delListener);
+    autoSaveListenerId = void 0;
+    return persister;
+  };
+  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+  const schedule = async (...actions) => {
+    arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+    await run();
+    return persister;
+  };
+  const getStore = () => store;
+  const destroy = () => stopAutoLoad().stopAutoSave();
+  const getStats = () => ({loads, saves});
+  const persister = {
+    load,
+    startAutoLoad,
+    stopAutoLoad,
+    isAutoLoading,
+    save,
+    startAutoSave,
+    stopAutoSave,
+    isAutoSaving,
+    schedule,
+    getStore,
+    destroy,
+    getStats,
+    ...extra,
   };
-  if (getThing) {
-    persister[getThing] = () => thing;
-  }
   return objFreeze(persister);
 };
 
@@ -208,56 +251,51 @@ const getDocContent = (doc, docObjName) => [
   doc[docObjName].t,
   doc[docObjName].v,
 ];
-const setTransactionChangesToDoc = (
-  doc,
-  docObjName,
-  getContent,
-  getTransactionChanges,
-) => {
+const applyChangesToDoc = (doc, docObjName, getContent, changes) => {
   ensureDocContent(doc, docObjName);
   const [docTables, docValues] = getDocContent(doc, docObjName);
-  const transactionChangesDidFail = () => {
-    transactionChangesFailed = 1;
+  const changesDidFail = () => {
+    changesFailed = 1;
   };
-  let transactionChangesFailed = 1;
-  ifNotUndefined(getTransactionChanges?.(), ([cellChanges, valueChanges]) => {
-    transactionChangesFailed = 0;
-    objMap(cellChanges, (table, tableId) =>
-      transactionChangesFailed
+  let changesFailed = 1;
+  ifNotUndefined(changes, ([cellChanges, valueChanges]) => {
+    changesFailed = 0;
+    objToArray(cellChanges, (table, tableId) =>
+      changesFailed
         ? 0
         : isUndefined(table)
           ? objDel(docTables, tableId)
           : ifNotUndefined(
               docTables[tableId],
               (docTable) =>
-                objMap(table, (row, rowId) =>
-                  transactionChangesFailed
+                objToArray(table, (row, rowId) =>
+                  changesFailed
                     ? 0
                     : isUndefined(row)
                       ? objDel(docTable, rowId)
                       : ifNotUndefined(
                           objGet(docTable, rowId),
                           (docRow) =>
-                            objMap(row, (cell, cellId) =>
+                            objToArray(row, (cell, cellId) =>
                               isUndefined(cell)
                                 ? objDel(docRow, cellId)
                                 : (docRow[cellId] = cell),
                             ),
-                          transactionChangesDidFail,
+                          changesDidFail,
                         ),
                 ),
-              transactionChangesDidFail,
+              changesDidFail,
             ),
     );
-    objMap(valueChanges, (value, valueId) =>
-      transactionChangesFailed
+    objToArray(valueChanges, (value, valueId) =>
+      changesFailed
         ? 0
         : isUndefined(value)
           ? objDel(docValues, valueId)
           : (docValues[valueId] = value),
     );
   });
-  if (transactionChangesFailed) {
+  if (changesFailed) {
     const [tables, values] = getContent();
     docObjMatch(docTables, void 0, tables, (_, tableId, table) =>
       docObjMatch(docTables, tableId, table, (docTable, rowId, row) =>
@@ -281,12 +319,12 @@ const docObjMatch = (docObjOrParent, idInParent, obj, set) => {
     ? docObjOrParent
     : objEnsure(docObjOrParent, idInParent, () => ({}));
   let changed;
-  objMap(obj, (value, id) => {
+  objToArray(obj, (value, id) => {
     if (set(docObj, id, value)) {
       changed = 1;
     }
   });
-  objMap(docObj, (_, id) => {
+  objToArray(docObj, (_, id) => {
     if (!objHas(obj, id)) {
       objDel(docObj, id);
       changed = 1;
@@ -304,21 +342,18 @@ const createAutomergePersister = (
   onIgnoredError,
 ) => {
   docHandle.change((doc) => (doc[docObjName] = {}));
-  const getPersisted = async () =>
-    objSize(docHandle.doc[docObjName]) == 2
-      ? getDocContent(docHandle.doc, docObjName)
+  const getPersisted = async () => {
+    const doc = await docHandle.doc();
+    return objSize(doc[docObjName]) == 2
+      ? getDocContent(doc, docObjName)
       : void 0;
-  const setPersisted = async (getContent, getTransactionChanges) =>
+  };
+  const setPersisted = async (getContent, changes) =>
     docHandle.change((doc) =>
-      setTransactionChangesToDoc(
-        doc,
-        docObjName,
-        getContent,
-        getTransactionChanges,
-      ),
+      applyChangesToDoc(doc, docObjName, getContent, changes),
     );
   const addPersisterListener = (listener) => {
-    const observer = ({doc}) => listener(() => getDocContent(doc, docObjName));
+    const observer = ({doc}) => listener(getDocContent(doc, docObjName));
     docHandle.on('change', observer);
     return observer;
   };
@@ -332,7 +367,8 @@ const createAutomergePersister = (
     addPersisterListener,
     delPersisterListener,
     onIgnoredError,
-    ['getDocHandle', docHandle],
+    1,
+    {getDocHandle: () => docHandle},
   );
 };