tinybase 4.0.0-beta.4 → 4.0.0-beta.5

package/lib/debug/{persister-yjs.js → persisters/persister-yjs.js}

@@ -1,9 +1,12 @@
 import {Map} from 'yjs';
 
+const TINYBASE = 'tinybase';
+
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayMap = (array, cb) => array.map(cb);
 const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
+const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
 
 const isUndefined = (thing) => thing == void 0;
@@ -12,7 +15,7 @@ const ifNotUndefined = (value, then, otherwise) =>
 
 const object = Object;
 const objFreeze = object.freeze;
-const objNew = () => ({});
+const objNew = (entries = []) => object.fromEntries(entries);
 const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
 const objHas = (obj, id) => !isUndefined(objGet(obj, id));
 const objMap = (obj, cb) =>
@@ -35,8 +38,23 @@ const createCustomPersister = (
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
-  let listening = false;
+  let running = 0;
+  let listening = 0;
+  let action;
   let listeningHandle;
+  const scheduledActions = [];
+  const run = async () => {
+    /* istanbul ignore else */
+    if (!running) {
+      running = 1;
+      while (!isUndefined((action = arrayShift(scheduledActions)))) {
+        try {
+          await action();
+        } catch {}
+      }
+      running = 0;
+    }
+  };
   const loadLock = async (actions) => {
     /* istanbul ignore else */
     if (loadSave != 2) {
@@ -51,18 +69,18 @@ const createCustomPersister = (
   const persister = {
     load: async (initialTables = {}, initialValues = {}) => {
       await loadLock(async () => {
-        let content;
         try {
-          content = await getPersisted();
-        } catch {}
-        store.setContent(content ?? [initialTables, initialValues]);
+          store.setContent(await getPersisted());
+        } catch {
+          store.setContent([initialTables, initialValues]);
+        }
       });
       return persister;
     },
     startAutoLoad: async (initialTables = {}, initialValues = {}) => {
       persister.stopAutoLoad();
       await persister.load(initialTables, initialValues);
-      listening = true;
+      listening = 1;
       listeningHandle = addPersisterListener(
         async (getContent, getTransactionChanges) => {
           await loadLock(async () => {
@@ -82,27 +100,33 @@ const createCustomPersister = (
       if (listening) {
         delPersisterListener(listeningHandle);
         listeningHandle = void 0;
-        listening = false;
+        listening = 0;
       }
       return persister;
     },
     save: async (getTransactionChanges) => {
-      /* istanbul ignore else */
-      if (loadSave != 1) {
-        loadSave = 2;
-        {
-          saves++;
+      await persister.schedule(async () => {
+        /* istanbul ignore else */
+        if (loadSave != 1) {
+          loadSave = 2;
+          {
+            saves++;
+          }
+          try {
+            await setPersisted(store.getContent, getTransactionChanges);
+          } catch {}
+          loadSave = 0;
         }
-        await setPersisted(store.getContent, getTransactionChanges);
-        loadSave = 0;
-      }
+      });
       return persister;
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
       listenerId = store.addDidFinishTransactionListener(
-        (_store, getTransactionChanges) =>
-          persister.save(getTransactionChanges),
+        (_store, getTransactionChanges) => {
+          const transactionChanges = getTransactionChanges();
+          persister.save(() => transactionChanges);
+        },
       );
       return persister;
     },
@@ -110,6 +134,11 @@ const createCustomPersister = (
       ifNotUndefined(listenerId, store.delListener);
       return persister;
     },
+    schedule: async (...actions) => {
+      arrayPush(scheduledActions, ...actions);
+      await run();
+      return persister;
+    },
     getStore: () => store,
     destroy: () => persister.stopAutoLoad().stopAutoSave(),
     getStats: () => ({loads, saves}),
@@ -273,7 +302,7 @@ const yMapMatch = (yMapOrParent, idInParent, obj, set) => {
   }
   return changed;
 };
-const createYjsPersister = (store, yDoc, yMapName = 'tinybase') => {
+const createYjsPersister = (store, yDoc, yMapName = TINYBASE) => {
   const yContent = yDoc.getMap(yMapName);
   const getPersisted = async () =>
     yContent.size

package/lib/debug/persisters.js

@@ -1,3 +1,6 @@
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
 const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
   isUndefined(value) ? otherwise?.() : then(value);
@@ -16,8 +19,23 @@ const createCustomPersister = (
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
-  let listening = false;
+  let running = 0;
+  let listening = 0;
+  let action;
   let listeningHandle;
+  const scheduledActions = [];
+  const run = async () => {
+    /* istanbul ignore else */
+    if (!running) {
+      running = 1;
+      while (!isUndefined((action = arrayShift(scheduledActions)))) {
+        try {
+          await action();
+        } catch {}
+      }
+      running = 0;
+    }
+  };
   const loadLock = async (actions) => {
     /* istanbul ignore else */
     if (loadSave != 2) {
@@ -32,18 +50,18 @@ const createCustomPersister = (
   const persister = {
     load: async (initialTables = {}, initialValues = {}) => {
       await loadLock(async () => {
-        let content;
         try {
-          content = await getPersisted();
-        } catch {}
-        store.setContent(content ?? [initialTables, initialValues]);
+          store.setContent(await getPersisted());
+        } catch {
+          store.setContent([initialTables, initialValues]);
+        }
       });
       return persister;
     },
     startAutoLoad: async (initialTables = {}, initialValues = {}) => {
       persister.stopAutoLoad();
       await persister.load(initialTables, initialValues);
-      listening = true;
+      listening = 1;
       listeningHandle = addPersisterListener(
         async (getContent, getTransactionChanges) => {
           await loadLock(async () => {
@@ -63,27 +81,33 @@ const createCustomPersister = (
       if (listening) {
         delPersisterListener(listeningHandle);
         listeningHandle = void 0;
-        listening = false;
+        listening = 0;
       }
       return persister;
     },
     save: async (getTransactionChanges) => {
-      /* istanbul ignore else */
-      if (loadSave != 1) {
-        loadSave = 2;
-        {
-          saves++;
+      await persister.schedule(async () => {
+        /* istanbul ignore else */
+        if (loadSave != 1) {
+          loadSave = 2;
+          {
+            saves++;
+          }
+          try {
+            await setPersisted(store.getContent, getTransactionChanges);
+          } catch {}
+          loadSave = 0;
         }
-        await setPersisted(store.getContent, getTransactionChanges);
-        loadSave = 0;
-      }
+      });
       return persister;
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
       listenerId = store.addDidFinishTransactionListener(
-        (_store, getTransactionChanges) =>
-          persister.save(getTransactionChanges),
+        (_store, getTransactionChanges) => {
+          const transactionChanges = getTransactionChanges();
+          persister.save(() => transactionChanges);
+        },
       );
       return persister;
     },
@@ -91,6 +115,11 @@ const createCustomPersister = (
       ifNotUndefined(listenerId, store.delListener);
       return persister;
     },
+    schedule: async (...actions) => {
+      arrayPush(scheduledActions, ...actions);
+      await run();
+      return persister;
+    },
     getStore: () => store,
     destroy: () => persister.stopAutoLoad().stopAutoSave(),
     getStats: () => ({loads, saves}),

package/lib/debug/store.js

@@ -30,7 +30,6 @@ const arraySort = (array, sorter) => array.sort(sorter);
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayMap = (array, cb) => array.map(cb);
 const arrayLength = (array) => array.length;
-const arrayIsEmpty = (array) => arrayLength(array) == 0;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayPush = (array, ...values) => array.push(...values);
@@ -68,10 +67,14 @@ const isObject = (obj) =>
   isInstanceOf(obj, object) && obj.constructor == object;
 const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
 const objHas = (obj, id) => !isUndefined(objGet(obj, id));
-const objDel = (obj, id) => delete obj[id];
+const objDel = (obj, id) => {
+  delete obj[id];
+  return obj;
+};
 const objMap = (obj, cb) =>
   arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
+const objSize = (obj) => arrayLength(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
@@ -101,6 +104,11 @@ const mapEnsure = (map, key, getDefaultValue) => {
   }
   return mapGet(map, key);
 };
+const mapMatch = (map, obj, set, del = mapSet) => {
+  objMap(obj, (value, id) => set(map, id, value));
+  mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
+  return map;
+};
 const mapToObj = (map, mapValue, excludeValue) => {
   const obj = {};
   collForEach(map, (value, id) => {
@@ -263,11 +271,6 @@ const setOrDelValue = (store, valueId, value) =>
 
 const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
 
-const mapMatch = (map, obj, set, del = mapSet) => {
-  objMap(obj, (value, id2) => set(map, id2, value));
-  mapForEach(map, (id2) => (objHas(obj, id2) ? 0 : del(map, id2)));
-  return map;
-};
 const validate = (obj, validateChild, onInvalidObj) => {
   if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
     onInvalidObj?.();
@@ -293,6 +296,7 @@ const createStore = () => {
   let valuesTouched = false;
   let transactions = 0;
   const changedTableIds = mapNew();
+  const changedTableCellIds = mapNew();
   const changedRowIds = mapNew();
   const changedCellIds = mapNew();
   const changedCells = mapNew();
@@ -306,11 +310,13 @@ const createStore = () => {
   const valuesDefaulted = mapNew();
   const valuesNonDefaulted = setNew();
   const tablePoolFunctions = mapNew();
+  const tableCellIds = mapNew();
   const tablesMap = mapNew();
   const valuesMap = mapNew();
   const tablesListeners = pairNewMap();
   const tableIdsListeners = pairNewMap();
   const tableListeners = pairNewMap();
+  const tableCellIdsListeners = pairNewMap();
   const rowIdsListeners = pairNewMap();
   const sortedRowIdsListeners = pairNewMap();
   const rowListeners = pairNewMap();
@@ -499,6 +505,8 @@ const createStore = () => {
     mapMatch(
       mapEnsure(tablesMap, tableId, () => {
         tableIdsChanged(tableId, 1);
+        mapSet(tablePoolFunctions, tableId, getPoolFunctions());
+        mapSet(tableCellIds, tableId, mapNew());
         return mapNew();
       }),
       table,
@@ -559,7 +567,7 @@ const createStore = () => {
     }
   };
   const getNewRowId = (tableId, reuse) => {
-    const [getId] = mapEnsure(tablePoolFunctions, tableId, getPoolFunctions);
+    const [getId] = mapGet(tablePoolFunctions, tableId);
     const rowId = getId(reuse);
     if (!collHas(mapGet(tablesMap, tableId), rowId)) {
       return rowId;
@@ -570,11 +578,7 @@ const createStore = () => {
     mapGet(tablesMap, tableId) ?? setValidTable(tableId, {});
   const delValidTable = (tableId) => setValidTable(tableId, {});
   const delValidRow = (tableId, tableMap, rowId) => {
-    const [, releaseId] = mapEnsure(
-      tablePoolFunctions,
-      tableId,
-      getPoolFunctions,
-    );
+    const [, releaseId] = mapGet(tablePoolFunctions, tableId);
     releaseId(rowId);
     setValidRow(tableId, tableMap, rowId, {}, true);
   };
@@ -598,6 +602,7 @@ const createStore = () => {
         tableIdsChanged(tableId, -1);
         mapSet(tablesMap, tableId);
         mapSet(tablePoolFunctions, tableId);
+        mapSet(tableCellIds, tableId);
       }
     }
   };
@@ -618,12 +623,30 @@ const createStore = () => {
       rowId,
       addedOrRemoved,
     );
-  const cellIdsChanged = (tableId, rowId, cellId, addedOrRemoved) =>
+  const cellIdsChanged = (tableId, rowId, cellId, addedOrRemoved) => {
+    const cellIds = mapGet(tableCellIds, tableId);
+    const count = mapGet(cellIds, cellId) ?? 0;
+    if (
+      (count == 0 && addedOrRemoved == 1) ||
+      (count == 1 && addedOrRemoved == -1)
+    ) {
+      idsChanged(
+        mapEnsure(changedTableCellIds, tableId, mapNew),
+        cellId,
+        addedOrRemoved,
+      );
+    }
+    mapSet(
+      cellIds,
+      cellId,
+      count != -addedOrRemoved ? count + addedOrRemoved : null,
+    );
     idsChanged(
       mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),
       cellId,
       addedOrRemoved,
     );
+  };
   const cellChanged = (tableId, rowId, cellId, oldCell, newCell) =>
     (mapEnsure(
       mapEnsure(mapEnsure(changedCells, tableId, mapNew), rowId, mapNew),
@@ -694,7 +717,7 @@ const createStore = () => {
       : 0;
   const callIdsListenersIfChanged = (listeners, changedIds, ids) => {
     if (!collIsEmpty(changedIds)) {
-      callListeners(listeners, ids);
+      callListeners(listeners, ids, () => mapToObj(changedIds));
       return 1;
     }
   };
@@ -704,6 +727,7 @@ const createStore = () => {
     );
     const emptyIdListeners =
       collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(tableCellIdsListeners[mutator]) &&
       collIsEmpty(rowIdsListeners[mutator]) &&
       emptySortedRowIdListeners &&
       collIsEmpty(tableIdsListeners[mutator]);
@@ -716,22 +740,29 @@ const createStore = () => {
       const changes = mutator
         ? [
             mapClone(changedTableIds),
+            mapClone2(changedTableCellIds),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
             mapClone3(changedCells),
           ]
-        : [changedTableIds, changedRowIds, changedCellIds, changedCells];
+        : [
+            changedTableIds,
+            changedTableCellIds,
+            changedRowIds,
+            changedCellIds,
+            changedCells,
+          ];
       if (!emptyIdListeners) {
-        collForEach(changes[2], (rowCellIds, tableId) =>
-          collForEach(rowCellIds, (changedIds, rowId) =>
-            callIdsListenersIfChanged(cellIdsListeners[mutator], changedIds, [
-              tableId,
-              rowId,
-            ]),
+        callIdsListenersIfChanged(tableIdsListeners[mutator], changes[0]);
+        collForEach(changes[1], (changedIds, tableId) =>
+          callIdsListenersIfChanged(
+            tableCellIdsListeners[mutator],
+            changedIds,
+            [tableId],
           ),
         );
         const calledSortableTableIds = setNew();
-        collForEach(changes[1], (changedIds, tableId) => {
+        collForEach(changes[2], (changedIds, tableId) => {
           if (
             callIdsListenersIfChanged(rowIdsListeners[mutator], changedIds, [
               tableId,
@@ -743,7 +774,7 @@ const createStore = () => {
           }
         });
         if (!emptySortedRowIdListeners) {
-          collForEach(changes[3], (rows, tableId) => {
+          collForEach(changes[4], (rows, tableId) => {
             if (!collHas(calledSortableTableIds, tableId)) {
               const sortableCellIds = setNew();
               collForEach(rows, (cells) =>
@@ -762,11 +793,18 @@ const createStore = () => {
             }
           });
         }
-        callIdsListenersIfChanged(tableIdsListeners[mutator], changes[0]);
+        collForEach(changes[3], (rowCellIds, tableId) =>
+          collForEach(rowCellIds, (changedIds, rowId) =>
+            callIdsListenersIfChanged(cellIdsListeners[mutator], changedIds, [
+              tableId,
+              rowId,
+            ]),
+          ),
+        );
       }
       if (!emptyOtherListeners) {
         let tablesChanged;
-        collForEach(changes[3], (rows, tableId) => {
+        collForEach(changes[4], (rows, tableId) => {
           let tableChanged;
           collForEach(rows, (cells, rowId) => {
             let rowChanged;
@@ -878,6 +916,8 @@ const createStore = () => {
   const getTables = () => mapToObj3(tablesMap);
   const getTableIds = () => mapKeys(tablesMap);
   const getTable = (tableId) => mapToObj2(mapGet(tablesMap, id(tableId)));
+  const getTableCellIds = (tableId) =>
+    mapKeys(mapGet(tableCellIds, id(tableId)));
   const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, id(tableId)));
   const getSortedRowIds = (tableId, cellId, descending, offset = 0, limit) =>
     arrayMap(
@@ -906,6 +946,8 @@ const createStore = () => {
   const getValue = (valueId) => mapGet(valuesMap, id(valueId));
   const hasTables = () => !collIsEmpty(tablesMap);
   const hasTable = (tableId) => collHas(tablesMap, id(tableId));
+  const hasTableCell = (tableId, cellId) =>
+    collHas(mapGet(tableCellIds, id(tableId)), id(cellId));
   const hasRow = (tableId, rowId) =>
     collHas(mapGet(tablesMap, id(tableId)), id(rowId));
   const hasCell = (tableId, rowId, cellId) =>
@@ -1219,6 +1261,7 @@ const createStore = () => {
         arrayForEach(
           [
             changedTableIds,
+            changedTableCellIds,
             changedRowIds,
             changedCellIds,
             changedCells,
@@ -1243,6 +1286,8 @@ const createStore = () => {
         ),
       ),
     );
+  const forEachTableCell = (tableId, tableCellCallback) =>
+    mapForEach(mapGet(tableCellIds, id(tableId)), tableCellCallback);
   const forEachRow = (tableId, rowCallback) =>
     collForEach(mapGet(tablesMap, id(tableId)), (rowMap, rowId) =>
       rowCallback(rowId, (cellCallback) => mapForEach(rowMap, cellCallback)),
@@ -1310,6 +1355,7 @@ const createStore = () => {
   const getListenerStats = () => ({
     tables: pairCollSize2(tablesListeners),
     tableIds: pairCollSize2(tableIdsListeners),
+    tableCellIds: pairCollSize2(tableCellIdsListeners),
     table: pairCollSize2(tableListeners),
     rowIds: pairCollSize2(rowIdsListeners),
     sortedRowIds: pairCollSize2(sortedRowIdsListeners),
@@ -1330,6 +1376,7 @@ const createStore = () => {
     getTables,
     getTableIds,
     getTable,
+    getTableCellIds,
     getRowIds,
     getSortedRowIds,
     getRow,
@@ -1340,6 +1387,7 @@ const createStore = () => {
     getValue,
     hasTables,
     hasTable,
+    hasTableCell,
     hasRow,
     hasCell,
     hasValues,
@@ -1380,6 +1428,7 @@ const createStore = () => {
     startTransaction,
     finishTransaction,
     forEachTable,
+    forEachTableCell,
     forEachRow,
     forEachCell,
     forEachValue,
@@ -1397,6 +1446,7 @@ const createStore = () => {
       [TABLES]: [0, tablesListeners],
       [TABLE_IDS]: [0, tableIdsListeners],
       [TABLE]: [1, tableListeners, [getTableIds]],
+      [TABLE + CELL_IDS]: [1, tableCellIdsListeners, [getTableIds]],
       [ROW_IDS]: [1, rowIdsListeners, [getTableIds]],
       [ROW]: [2, rowListeners, [getTableIds, getRowIds]],
       [CELL_IDS]: [2, cellIdsListeners, [getTableIds, getRowIds]],