tinybase 3.2.0-beta.0 → 3.3.0

package/lib/debug/store.js

@@ -32,7 +32,6 @@ 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 arrayFilter = (array, cb) => array.filter(cb);
 const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
@@ -141,7 +140,7 @@ const getPoolFunctions = () => {
   const pool = [];
   let nextId = 0;
   return [
-    () => arrayShift(pool) ?? EMPTY_STRING + nextId++,
+    (reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,
     (id) => {
       if (test(INTEGER, id) && arrayLength(pool) < 1e3) {
         arrayPush(pool, id);
@@ -173,7 +172,7 @@ const getListenerFunctions = (getThing) => {
     extraArgsGetter = () => [],
   ) => {
     thing ??= getThing();
-    const id = getId();
+    const id = getId(1);
     mapSet(allListeners, id, [
       listener,
       idSetNode,
@@ -252,15 +251,9 @@ const setOrDelValue = (store, valueId, value) =>
 
 const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
 
-const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
-  const idsToDelete = arrayFilter(
-    mapKeys(map),
-    (id2) => !objHas(toBeLikeObject, id2),
-  );
-  arrayForEach(objIds(toBeLikeObject), (id2) =>
-    setId(map, id2, toBeLikeObject[id2]),
-  );
-  arrayForEach(idsToDelete, (id2) => delId(map, id2));
+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) => {
@@ -284,6 +277,7 @@ const createStore = () => {
   let valuesTouched;
   let transactions = 0;
   const changedTableIds = mapNew();
+  const changedTableCellIds = mapNew();
   const changedRowIds = mapNew();
   const changedCellIds = mapNew();
   const changedCells = mapNew();
@@ -297,11 +291,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();
@@ -312,6 +308,7 @@ const createStore = () => {
   const valuesListeners = pairNewMap();
   const valueIdsListeners = pairNewMap();
   const valueListeners = pairNewMap();
+  const startTransactionListeners = mapNew();
   const finishTransactionListeners = pairNewMap();
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
@@ -433,13 +430,13 @@ const createStore = () => {
     return values;
   };
   const setValidTablesSchema = (tablesSchema) =>
-    transformMap(
+    mapMatch(
       tablesSchemaMap,
       tablesSchema,
       (_tablesSchema, tableId, tableSchema) => {
         const rowDefaulted = mapNew();
         const rowNonDefaulted = setNew();
-        transformMap(
+        mapMatch(
           mapEnsure(tablesSchemaMap, tableId, mapNew),
           tableSchema,
           (tableSchemaMap, cellId, cellSchema) => {
@@ -459,7 +456,7 @@ const createStore = () => {
       },
     );
   const setValidValuesSchema = (valuesSchema) =>
-    transformMap(
+    mapMatch(
       valuesSchemaMap,
       valuesSchema,
       (_valuesSchema, valueId, valueSchema) => {
@@ -479,16 +476,18 @@ const createStore = () => {
   const setOrDelTables = (tables) =>
     objIsEmpty(tables) ? delTables() : setTables(tables);
   const setValidTables = (tables) =>
-    transformMap(
+    mapMatch(
       tablesMap,
       tables,
       (_tables, tableId, table) => setValidTable(tableId, table),
       (_tables, tableId) => delValidTable(tableId),
     );
   const setValidTable = (tableId, table) =>
-    transformMap(
+    mapMatch(
       mapEnsure(tablesMap, tableId, () => {
         tableIdsChanged(tableId, 1);
+        mapSet(tablePoolFunctions, tableId, getPoolFunctions());
+        mapSet(tableCellIds, tableId, mapNew());
         return mapNew();
       }),
       table,
@@ -496,7 +495,7 @@ const createStore = () => {
       (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
     );
   const setValidRow = (tableId, tableMap, rowId, row, forceDel) =>
-    transformMap(
+    mapMatch(
       mapEnsure(tableMap, rowId, () => {
         rowIdsChanged(tableId, rowId, 1);
         return mapNew();
@@ -532,7 +531,7 @@ const createStore = () => {
   const setOrDelValues = (values) =>
     objIsEmpty(values) ? delValues() : setValues(values);
   const setValidValues = (values) =>
-    transformMap(
+    mapMatch(
       valuesMap,
       values,
       (_valuesMap, valueId, value) => setValidValue(valueId, value),
@@ -548,23 +547,19 @@ const createStore = () => {
       mapSet(valuesMap, valueId, value);
     }
   };
-  const getNewRowId = (tableId) => {
-    const [getId] = mapEnsure(tablePoolFunctions, tableId, getPoolFunctions);
-    const rowId = getId();
+  const getNewRowId = (tableId, reuse) => {
+    const [getId] = mapGet(tablePoolFunctions, tableId);
+    const rowId = getId(reuse);
     if (!collHas(mapGet(tablesMap, tableId), rowId)) {
       return rowId;
     }
-    return getNewRowId(tableId);
+    return getNewRowId(tableId, reuse);
   };
   const getOrCreateTable = (tableId) =>
     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);
   };
@@ -588,6 +583,7 @@ const createStore = () => {
         tableIdsChanged(tableId, -1);
         mapSet(tablesMap, tableId);
         mapSet(tablePoolFunctions, tableId);
+        mapSet(tableCellIds, tableId);
       }
     }
   };
@@ -604,12 +600,23 @@ const createStore = () => {
     idsChanged(changedTableIds, tableId, added);
   const rowIdsChanged = (tableId, rowId, added) =>
     idsChanged(mapEnsure(changedRowIds, tableId, mapNew), rowId, added);
-  const cellIdsChanged = (tableId, rowId, cellId, added) =>
+  const cellIdsChanged = (tableId, rowId, cellId, added) => {
+    const cellIds = mapGet(tableCellIds, tableId);
+    const count = mapGet(cellIds, cellId) ?? 0;
+    if ((count == 0 && added == 1) || (count == 1 && added == -1)) {
+      idsChanged(
+        mapEnsure(changedTableCellIds, tableId, mapNew),
+        cellId,
+        added,
+      );
+    }
+    mapSet(cellIds, cellId, count != -added ? count + added : null);
     idsChanged(
       mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),
       cellId,
       added,
     );
+  };
   const cellChanged = (tableId, rowId, cellId, oldCell, newCell) =>
     (mapEnsure(
       mapEnsure(mapEnsure(changedCells, tableId, mapNew), rowId, mapNew),
@@ -680,7 +687,7 @@ const createStore = () => {
       : 0;
   const callIdsListenersIfChanged = (listeners, changedIds, ids) => {
     if (!collIsEmpty(changedIds)) {
-      callListeners(listeners, ids);
+      callListeners(listeners, ids, () => mapToObj(changedIds));
       return 1;
     }
   };
@@ -690,6 +697,7 @@ const createStore = () => {
     );
     const emptyIdListeners =
       collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(tableCellIdsListeners[mutator]) &&
       collIsEmpty(rowIdsListeners[mutator]) &&
       emptySortedRowIdListeners &&
       collIsEmpty(tableIdsListeners[mutator]);
@@ -702,13 +710,27 @@ const createStore = () => {
       const changes = mutator
         ? [
             mapClone(changedTableIds),
+            mapClone2(changedTableCellIds),
             mapClone2(changedRowIds),
             mapClone(changedCellIds, mapClone2),
             mapClone(changedCells, mapClone2),
           ]
-        : [changedTableIds, changedRowIds, changedCellIds, changedCells];
+        : [
+            changedTableIds,
+            changedTableCellIds,
+            changedRowIds,
+            changedCellIds,
+            changedCells,
+          ];
       if (!emptyIdListeners) {
-        collForEach(changes[2], (rowCellIds, tableId) =>
+        collForEach(changes[1], (changedIds, tableId) =>
+          callIdsListenersIfChanged(
+            tableCellIdsListeners[mutator],
+            changedIds,
+            [tableId],
+          ),
+        );
+        collForEach(changes[3], (rowCellIds, tableId) =>
           collForEach(rowCellIds, (changedIds, rowId) =>
             callIdsListenersIfChanged(cellIdsListeners[mutator], changedIds, [
               tableId,
@@ -717,7 +739,7 @@ const createStore = () => {
           ),
         );
         const calledSortableTableIds = setNew();
-        collForEach(changes[1], (changedIds, tableId) => {
+        collForEach(changes[2], (changedIds, tableId) => {
           if (
             callIdsListenersIfChanged(rowIdsListeners[mutator], changedIds, [
               tableId,
@@ -729,7 +751,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) =>
@@ -752,7 +774,7 @@ const createStore = () => {
       }
       if (!emptyOtherListeners) {
         let tablesChanged;
-        collForEach(changes[3], (rows, tableId) => {
+        collForEach(changes[4], (rows, tableId) => {
           let tableChanged;
           collForEach(rows, (cells, rowId) => {
             let rowChanged;
@@ -827,6 +849,8 @@ const createStore = () => {
   const getTableIds = () => mapKeys(tablesMap);
   const getTable = (tableId) =>
     mapToObj(mapGet(tablesMap, id(tableId)), mapToObj);
+  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(
@@ -855,6 +879,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) =>
@@ -886,7 +912,7 @@ const createStore = () => {
       tableId,
       rowId,
     );
-  const addRow = (tableId, row) =>
+  const addRow = (tableId, row, reuseRowIds = true) =>
     transaction(() => {
       let rowId = void 0;
       if (validateRow(tableId, rowId, row)) {
@@ -894,7 +920,7 @@ const createStore = () => {
         setValidRow(
           tableId,
           getOrCreateTable(tableId),
-          (rowId = getNewRowId(tableId)),
+          (rowId = getNewRowId(tableId, reuseRowIds ? 1 : 0)),
           row,
         );
       }
@@ -1071,16 +1097,20 @@ const createStore = () => {
       delValuesSchema();
     });
   const transaction = (actions, doRollback) => {
-    if (transactions == -1) {
-      return;
+    if (transactions != -1) {
+      startTransaction();
+      const result = actions();
+      finishTransaction(doRollback);
+      return result;
     }
-    startTransaction();
-    const result = actions();
-    finishTransaction(doRollback);
-    return result;
   };
   const startTransaction = () => {
-    transactions++;
+    if (transactions != -1) {
+      transactions++;
+    }
+    if (transactions == 1) {
+      callListeners(startTransactionListeners, void 0, false, false);
+    }
     return store;
   };
   const finishTransaction = (doRollback) => {
@@ -1098,7 +1128,6 @@ const createStore = () => {
         if (valuesTouched) {
           callKeyedValuesListenersForChanges(1);
         }
-        transactions = -1;
         if (
           doRollback?.(
             mapToObj(
@@ -1125,7 +1154,6 @@ const createStore = () => {
             mapToObj(invalidValues),
           )
         ) {
-          transactions = 1;
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
@@ -1136,7 +1164,6 @@ const createStore = () => {
           collForEach(changedValues, ([oldValue], valueId) =>
             setOrDelValue(store, valueId, oldValue),
           );
-          transactions = -1;
           cellsTouched = valuesTouched = false;
         }
         callListeners(
@@ -1145,6 +1172,7 @@ const createStore = () => {
           cellsTouched,
           valuesTouched,
         );
+        transactions = -1;
         callInvalidCellListeners(0);
         if (cellsTouched) {
           callTabularListenersForChanges(0);
@@ -1163,6 +1191,7 @@ const createStore = () => {
         arrayForEach(
           [
             changedTableIds,
+            changedTableCellIds,
             changedRowIds,
             changedCellIds,
             changedCells,
@@ -1187,6 +1216,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)),
@@ -1237,6 +1268,8 @@ const createStore = () => {
       [getTableIds],
     );
   };
+  const addStartTransactionListener = (listener) =>
+    addListener(listener, startTransactionListeners);
   const addWillFinishTransactionListener = (listener) =>
     addListener(listener, finishTransactionListeners[0]);
   const addDidFinishTransactionListener = (listener) =>
@@ -1252,6 +1285,7 @@ const createStore = () => {
   const getListenerStats = () => ({
     tables: pairCollSize2(tablesListeners),
     tableIds: pairCollSize2(tableIdsListeners),
+    tableCellIds: pairCollSize2(tableCellIdsListeners),
     table: pairCollSize2(tableListeners),
     rowIds: pairCollSize2(rowIdsListeners),
     sortedRowIds: pairCollSize2(sortedRowIdsListeners),
@@ -1263,12 +1297,15 @@ const createStore = () => {
     valueIds: pairCollSize2(valueIdsListeners),
     value: pairCollSize2(valueListeners),
     invalidValue: pairCollSize2(invalidValueListeners),
-    transaction: pairCollSize2(finishTransactionListeners),
+    transaction:
+      collSize2(startTransactionListeners) +
+      pairCollSize2(finishTransactionListeners),
   });
   const store = {
     getTables,
     getTableIds,
     getTable,
+    getTableCellIds,
     getRowIds,
     getSortedRowIds,
     getRow,
@@ -1279,6 +1316,7 @@ const createStore = () => {
     getValue,
     hasTables,
     hasTable,
+    hasTableCell,
     hasRow,
     hasCell,
     hasValues,
@@ -1317,10 +1355,12 @@ const createStore = () => {
     startTransaction,
     finishTransaction,
     forEachTable,
+    forEachTableCell,
     forEachRow,
     forEachCell,
     forEachValue,
     addSortedRowIdsListener,
+    addStartTransactionListener,
     addWillFinishTransactionListener,
     addDidFinishTransactionListener,
     callListener,
@@ -1333,6 +1373,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]],