tinybase 4.0.0-beta.4 → 4.0.0-beta.5.1

package/lib/debug/tinybase.js

@@ -88,10 +88,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);
@@ -121,6 +125,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) => {
@@ -1029,8 +1038,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) {
@@ -1043,20 +1067,20 @@ const createCustomPersister = (
     }
   };
   const persister = {
-    load: async (initialTables = {}, initialValues = {}) => {
+    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 () => {
@@ -1076,27 +1100,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;
     },
@@ -1104,6 +1134,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}),
@@ -1743,11 +1778,6 @@ const pairNewMap = () => [mapNew(), mapNew()];
 const pairClone = (array) => [...array];
 const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
 
-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?.();
@@ -1773,6 +1803,7 @@ const createStore = () => {
   let valuesTouched = false;
   let transactions = 0;
   const changedTableIds = mapNew();
+  const changedTableCellIds = mapNew();
   const changedRowIds = mapNew();
   const changedCellIds = mapNew();
   const changedCells = mapNew();
@@ -1786,11 +1817,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();
@@ -1979,6 +2012,8 @@ const createStore = () => {
     mapMatch(
       mapEnsure(tablesMap, tableId, () => {
         tableIdsChanged(tableId, 1);
+        mapSet(tablePoolFunctions, tableId, getPoolFunctions());
+        mapSet(tableCellIds, tableId, mapNew());
         return mapNew();
       }),
       table,
@@ -2039,7 +2074,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;
@@ -2050,11 +2085,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);
   };
@@ -2078,6 +2109,7 @@ const createStore = () => {
         tableIdsChanged(tableId, -1);
         mapSet(tablesMap, tableId);
         mapSet(tablePoolFunctions, tableId);
+        mapSet(tableCellIds, tableId);
       }
     }
   };
@@ -2098,12 +2130,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),
@@ -2174,7 +2224,7 @@ const createStore = () => {
       : 0;
   const callIdsListenersIfChanged = (listeners, changedIds, ids) => {
     if (!collIsEmpty(changedIds)) {
-      callListeners(listeners, ids);
+      callListeners(listeners, ids, () => mapToObj(changedIds));
       return 1;
     }
   };
@@ -2184,6 +2234,7 @@ const createStore = () => {
     );
     const emptyIdListeners =
       collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(tableCellIdsListeners[mutator]) &&
       collIsEmpty(rowIdsListeners[mutator]) &&
       emptySortedRowIdListeners &&
       collIsEmpty(tableIdsListeners[mutator]);
@@ -2196,22 +2247,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,
@@ -2223,7 +2281,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) =>
@@ -2242,11 +2300,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;
@@ -2358,6 +2423,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(
@@ -2386,6 +2453,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) =>
@@ -2400,8 +2469,8 @@ const createStore = () => {
   const getSchemaJson = () => jsonString([tablesSchemaMap, valuesSchemaMap]);
   const setContent = ([tables, values]) =>
     fluentTransaction(() => {
-      setTables(tables);
-      setValues(values);
+      (objIsEmpty(tables) ? delTables : setTables)(tables);
+      (objIsEmpty(values) ? delValues : setValues)(values);
     });
   const setTables = (tables) =>
     fluentTransaction(() =>
@@ -2699,6 +2768,7 @@ const createStore = () => {
         arrayForEach(
           [
             changedTableIds,
+            changedTableCellIds,
             changedRowIds,
             changedCellIds,
             changedCells,
@@ -2723,6 +2793,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)),
@@ -2790,6 +2862,7 @@ const createStore = () => {
   const getListenerStats = () => ({
     tables: pairCollSize2(tablesListeners),
     tableIds: pairCollSize2(tableIdsListeners),
+    tableCellIds: pairCollSize2(tableCellIdsListeners),
     table: pairCollSize2(tableListeners),
     rowIds: pairCollSize2(rowIdsListeners),
     sortedRowIds: pairCollSize2(sortedRowIdsListeners),
@@ -2810,6 +2883,7 @@ const createStore = () => {
     getTables,
     getTableIds,
     getTable,
+    getTableCellIds,
     getRowIds,
     getSortedRowIds,
     getRow,
@@ -2820,6 +2894,7 @@ const createStore = () => {
     getValue,
     hasTables,
     hasTable,
+    hasTableCell,
     hasRow,
     hasCell,
     hasValues,
@@ -2860,6 +2935,7 @@ const createStore = () => {
     startTransaction,
     finishTransaction,
     forEachTable,
+    forEachTableCell,
     forEachRow,
     forEachCell,
     forEachValue,
@@ -2877,6 +2953,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]],