tinybase 8.0.0-beta.0 → 8.0.0-beta.2

package/with-schemas/index.js

@@ -64,6 +64,7 @@ const size = (arrayOrString) => arrayOrString.length;
 const test = (regex, subject) => regex.test(subject);
 const getUndefined = () => void 0;
 const noop = () => {};
+const structuredClone = GLOBAL.structuredClone;
 const tryCatch = async (action, then1, then2) => {
   try {
     return await action();
@@ -99,25 +100,6 @@ const arrayPop = (array) => array.pop();
 const arrayUnshift = (array, ...values) => array.unshift(...values);
 const arrayShift = (array) => array.shift();
 
-const getCellOrValueType = (cellOrValue) => {
-  if (isNull(cellOrValue)) {
-    return NULL;
-  }
-  const type = getTypeOf(cellOrValue);
-  return isTypeStringOrBoolean(type) ||
-    (type == NUMBER && isFiniteNumber(cellOrValue))
-    ? type
-    : void 0;
-};
-const isCellOrValueOrUndefined = (cellOrValue) =>
-  isUndefined(cellOrValue) || !isUndefined(getCellOrValueType(cellOrValue));
-const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
-  isUndefined(cell)
-    ? store.delCell(tableId, rowId, cellId, true)
-    : store.setCell(tableId, rowId, cellId, cell);
-const setOrDelValue = (store, valueId, value) =>
-  isUndefined(value) ? store.delValue(valueId) : store.setValue(valueId, value);
-
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
 const collSize = (coll) => coll?.size ?? 0;
@@ -149,6 +131,7 @@ const isObject = (obj) =>
 const objIds = object.keys;
 const objFreeze = object.freeze;
 const objNew = (entries = []) => object.fromEntries(entries);
+const objMerge = (...objs) => object.assign({}, ...objs);
 const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
 const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
@@ -208,31 +191,32 @@ const objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
   return emptyIsValid ? true : !objIsEmpty(obj);
 };
 
-const mapNew = (entries) => new Map(entries);
-const mapKeys = (map) => [...(map?.keys() ?? [])];
-const mapGet = (map, key) => map?.get(key);
-const mapForEach = (map, cb) =>
-  collForEach(map, (value, key) => cb(key, value));
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapKeys = (map2) => [...(map2?.keys() ?? [])];
+const mapGet = (map2, key) => map2?.get(key);
+const mapForEach = (map2, cb) =>
+  collForEach(map2, (value, key) => cb(key, value));
 const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
-const mapSet = (map, key, value) =>
-  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map2, key)) {
+    mapSet(map2, key, getDefaultValue());
   } else {
-    hadExistingValue?.(mapGet(map, key));
+    hadExistingValue?.(mapGet(map2, key));
   }
-  return mapGet(map, key);
+  return mapGet(map2, 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 mapMatch = (map2, obj, set, del = mapSet) => {
+  objMap(obj, (value, id) => set(map2, id, value));
+  mapForEach(map2, (id) => (objHas(obj, id) ? 0 : del(map2, id)));
+  return map2;
 };
-const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
+const mapToObj = (map2, valueMapper, excludeMapValue, excludeObjValue) => {
   const obj = {};
-  collForEach(map, (mapValue, id) => {
+  collForEach(map2, (mapValue, id) => {
     if (!excludeMapValue?.(mapValue, id)) {
       const objValue = valueMapper ? valueMapper(mapValue, id) : mapValue;
       if (!excludeObjValue?.(objValue)) {
@@ -242,27 +226,27 @@ const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
   });
   return obj;
 };
-const mapToObj2 = (map, valueMapper, excludeMapValue) =>
+const mapToObj2 = (map2, valueMapper, excludeMapValue) =>
   mapToObj(
-    map,
+    map2,
     (childMap) => mapToObj(childMap, valueMapper, excludeMapValue),
     collIsEmpty,
     objIsEmpty,
   );
-const mapToObj3 = (map, valueMapper, excludeMapValue) =>
+const mapToObj3 = (map2, valueMapper, excludeMapValue) =>
   mapToObj(
-    map,
+    map2,
     (childMap) => mapToObj2(childMap, valueMapper, excludeMapValue),
     collIsEmpty,
     objIsEmpty,
   );
-const mapClone = (map, mapValue) => {
-  const map2 = mapNew();
-  collForEach(map, (value, key) => map2.set(key, mapValue?.(value) ?? value));
-  return map2;
+const mapClone = (map2, mapValue) => {
+  const map22 = mapNew();
+  collForEach(map2, (value, key) => map22.set(key, mapValue?.(value) ?? value));
+  return map22;
 };
-const mapClone2 = (map) => mapClone(map, mapClone);
-const mapClone3 = (map) => mapClone(map, mapClone2);
+const mapClone2 = (map2) => mapClone(map2, mapClone);
+const mapClone3 = (map2) => mapClone(map2, mapClone2);
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(
     (ensureLeaf ? mapEnsure : mapGet)(
@@ -576,12 +560,18 @@ const createCheckpoints = getCreateFunction(
         collForEach(cellsDelta2, (table, tableId) =>
           collForEach(table, (row, rowId) =>
             collForEach(row, (oldNew, cellId) =>
-              setOrDelCell(store, tableId, rowId, cellId, oldNew[oldOrNew]),
+              store.setOrDelCell(
+                tableId,
+                rowId,
+                cellId,
+                oldNew[oldOrNew],
+                true,
+              ),
             ),
           ),
         );
         collForEach(valuesDelta2, (oldNew, valueId) =>
-          setOrDelValue(store, valueId, oldNew[oldOrNew]),
+          store.setOrDelValue(valueId, oldNew[oldOrNew], true),
         );
       });
       listening = 1;
@@ -1167,6 +1157,19 @@ const createIndexes = getCreateFunction((store) => {
   return objFreeze(indexes);
 });
 
+const getCellOrValueType = (cellOrValue) => {
+  if (isNull(cellOrValue)) {
+    return NULL;
+  }
+  const type = getTypeOf(cellOrValue);
+  return isTypeStringOrBoolean(type) ||
+    (type == NUMBER && isFiniteNumber(cellOrValue))
+    ? type
+    : void 0;
+};
+const isCellOrValueOrUndefined = (cellOrValue) =>
+  isUndefined(cellOrValue) || !isUndefined(getCellOrValueType(cellOrValue));
+
 const stampClone = ([value, hlc]) => stampNew(value, hlc);
 const stampCloneWithHash = ([value, hlc, hash]) => [value, hlc, hash];
 const stampNew = (value, hlc) => (hlc ? [value, hlc] : [value]);
@@ -1211,13 +1214,17 @@ const idsChanged = (changedIds, id2, addedOrRemoved) =>
     id2,
     mapGet(changedIds, id2) == -addedOrRemoved ? void 0 : addedOrRemoved,
   );
+const contentOrChangesIsEqual = ([tables1, values1], [tables2, values2]) =>
+  objIsEqual(tables1, tables2) && objIsEqual(values1, values2);
 const createStore = () => {
   let hasTablesSchema;
   let hasValuesSchema;
   let hadTables = false;
   let hadValues = false;
   let transactions = 0;
+  let middleware = [];
   let internalListeners = [];
+  let mutating = 0;
   const changedTableIds = mapNew();
   const changedTableCellIds = mapNew();
   const changedRowCount = mapNew();
@@ -1263,6 +1270,19 @@ const createStore = () => {
   const finishTransactionListeners = pairNewMap();
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
+  const whileMutating = (action) => {
+    const wasMutating = mutating;
+    mutating = 1;
+    const result = action();
+    mutating = wasMutating;
+    return result;
+  };
+  const ifTransformed = (snapshot, getResult, then, isEqual = Object.is) =>
+    ifNotUndefined(getResult(), (result) =>
+      snapshot === result || isEqual(snapshot, result)
+        ? then(result)
+        : whileMutating(() => then(result)),
+    );
   const validateTablesSchema = (tableSchema) =>
     objValidate(tableSchema, (tableSchema2) =>
       objValidate(tableSchema2, validateCellOrValueSchema),
@@ -1450,82 +1470,194 @@ const createStore = () => {
     );
   const setOrDelTables = (tables) =>
     objIsEmpty(tables) ? delTables() : setTables(tables);
-  const setValidContent = ([tables, values]) => {
-    (objIsEmpty(tables) ? delTables : setTables)(tables);
-    (objIsEmpty(values) ? delValues : setValues)(values);
-  };
-  const setValidTables = (tables) =>
-    mapMatch(
-      tablesMap,
+  const setOrDelCell = (tableId, rowId, cellId, cell, skipMiddleware) =>
+    isUndefined(cell)
+      ? delCell(tableId, rowId, cellId, true, skipMiddleware)
+      : setCell(tableId, rowId, cellId, cell, skipMiddleware);
+  const setOrDelValues = (values) =>
+    objIsEmpty(values) ? delValues() : setValues(values);
+  const setOrDelValue = (valueId, value, skipMiddleware) =>
+    isUndefined(value)
+      ? delValue(valueId, skipMiddleware)
+      : setValue(valueId, value, skipMiddleware);
+  const setValidContent = (content) =>
+    ifTransformed(
+      content,
+      () =>
+        ifNotUndefined(
+          middleware[0],
+          (willSetContent) =>
+            whileMutating(() => willSetContent(structuredClone(content))),
+          () => content,
+        ),
+      ([tables, values]) => {
+        (objIsEmpty(tables) ? delTables : setTables)(tables);
+        (objIsEmpty(values) ? delValues : setValues)(values);
+      },
+      contentOrChangesIsEqual,
+    );
+  const setValidTables = (tables, forceDel) =>
+    ifTransformed(
       tables,
-      (_tables, tableId, table) => setValidTable(tableId, table),
-      (_tables, tableId) => delValidTable(tableId),
+      () =>
+        forceDel
+          ? tables
+          : ifNotUndefined(
+              middleware[1],
+              (willSetTables) =>
+                whileMutating(() => willSetTables(structuredClone(tables))),
+              () => tables,
+            ),
+      (validTables) =>
+        mapMatch(
+          tablesMap,
+          validTables,
+          (_tables, tableId, table) => setValidTable(tableId, table),
+          (_tables, tableId) => delValidTable(tableId),
+        ),
+      objIsEqual,
     );
-  const setValidTable = (tableId, table) =>
-    mapMatch(
-      mapEnsure(tablesMap, tableId, () => {
-        tableIdsChanged(tableId, 1);
-        mapSet(tablePoolFunctions, tableId, getPoolFunctions());
-        mapSet(tableCellIds, tableId, mapNew());
-        return mapNew();
-      }),
+  const setValidTable = (tableId, table, forceDel) =>
+    ifTransformed(
       table,
-      (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),
-      (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
+      () =>
+        forceDel
+          ? table
+          : ifNotUndefined(
+              middleware[2],
+              (willSetTable) =>
+                whileMutating(() =>
+                  willSetTable(tableId, structuredClone(table)),
+                ),
+              () => table,
+            ),
+      (validTable) =>
+        mapMatch(
+          mapEnsure(tablesMap, tableId, () => {
+            tableIdsChanged(tableId, 1);
+            mapSet(tablePoolFunctions, tableId, getPoolFunctions());
+            mapSet(tableCellIds, tableId, mapNew());
+            return mapNew();
+          }),
+          validTable,
+          (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),
+          (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
+        ),
+      objIsEqual,
     );
   const setValidRow = (tableId, tableMap, rowId, row, forceDel) =>
-    mapMatch(
-      mapEnsure(tableMap, rowId, () => {
-        rowIdsChanged(tableId, rowId, 1);
-        return mapNew();
-      }),
+    ifTransformed(
       row,
-      (rowMap, cellId, cell) =>
-        setValidCell(tableId, rowId, rowMap, cellId, cell),
-      (rowMap, cellId) =>
-        delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
-    );
-  const setValidCell = (tableId, rowId, rowMap, cellId, cell) => {
-    if (!collHas(rowMap, cellId)) {
-      cellIdsChanged(tableId, rowId, cellId, 1);
-    }
-    const oldCell = mapGet(rowMap, cellId);
-    if (cell !== oldCell) {
-      cellChanged(tableId, rowId, cellId, oldCell, cell);
-      mapSet(rowMap, cellId, cell);
-    }
-  };
-  const setCellIntoDefaultRow = (tableId, tableMap, rowId, cellId, validCell) =>
+      () =>
+        forceDel
+          ? row
+          : ifNotUndefined(
+              middleware[3],
+              (willSetRow) =>
+                whileMutating(() =>
+                  willSetRow(tableId, rowId, structuredClone(row)),
+                ),
+              () => row,
+            ),
+      (validRow) =>
+        mapMatch(
+          mapEnsure(tableMap, rowId, () => {
+            rowIdsChanged(tableId, rowId, 1);
+            return mapNew();
+          }),
+          validRow,
+          (rowMap, cellId, cell) =>
+            setValidCell(tableId, rowId, rowMap, cellId, cell),
+          (rowMap, cellId) =>
+            delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
+        ),
+      objIsEqual,
+    );
+  const setValidCell = (tableId, rowId, rowMap, cellId, cell, skipMiddleware) =>
+    ifTransformed(
+      cell,
+      () =>
+        ifNotUndefined(
+          skipMiddleware ? void 0 : middleware[4],
+          (willSetCell) =>
+            whileMutating(() => willSetCell(tableId, rowId, cellId, cell)),
+          () => cell,
+        ),
+      (cell2) => {
+        if (!collHas(rowMap, cellId)) {
+          cellIdsChanged(tableId, rowId, cellId, 1);
+        }
+        const oldCell = mapGet(rowMap, cellId);
+        if (cell2 !== oldCell) {
+          cellChanged(tableId, rowId, cellId, oldCell, cell2);
+          mapSet(rowMap, cellId, cell2);
+        }
+      },
+    );
+  const setCellIntoNewRow = (
+    tableId,
+    tableMap,
+    rowId,
+    cellId,
+    validCell,
+    skipMiddleware,
+  ) =>
     ifNotUndefined(
       mapGet(tableMap, rowId),
-      (rowMap) => setValidCell(tableId, rowId, rowMap, cellId, validCell),
-      () =>
-        setValidRow(
-          tableId,
-          tableMap,
-          rowId,
+      (rowMap) =>
+        setValidCell(tableId, rowId, rowMap, cellId, validCell, skipMiddleware),
+      () => {
+        const rowMap = mapNew();
+        mapSet(tableMap, rowId, rowMap);
+        rowIdsChanged(tableId, rowId, 1);
+        objMap(
           addDefaultsToRow({[cellId]: validCell}, tableId, rowId),
-        ),
+          (cell, cellId2) =>
+            setValidCell(tableId, rowId, rowMap, cellId2, cell, skipMiddleware),
+        );
+      },
     );
-  const setOrDelValues = (values) =>
-    objIsEmpty(values) ? delValues() : setValues(values);
-  const setValidValues = (values) =>
-    mapMatch(
-      valuesMap,
+  const setValidValues = (values, forceDel) =>
+    ifTransformed(
       values,
-      (_valuesMap, valueId, value) => setValidValue(valueId, value),
-      (_valuesMap, valueId) => delValidValue(valueId),
+      () =>
+        forceDel
+          ? values
+          : ifNotUndefined(
+              middleware[5],
+              (willSetValues) =>
+                whileMutating(() => willSetValues(structuredClone(values))),
+              () => values,
+            ),
+      (validValues) =>
+        mapMatch(
+          valuesMap,
+          validValues,
+          (_valuesMap, valueId, value) => setValidValue(valueId, value),
+          (_valuesMap, valueId) => delValidValue(valueId),
+        ),
+      objIsEqual,
+    );
+  const setValidValue = (valueId, value, skipMiddleware) =>
+    ifTransformed(
+      value,
+      () =>
+        ifNotUndefined(
+          skipMiddleware ? void 0 : middleware[6],
+          (willSetValue) => whileMutating(() => willSetValue(valueId, value)),
+          () => value,
+        ),
+      (value2) => {
+        if (!collHas(valuesMap, valueId)) {
+          valueIdsChanged(valueId, 1);
+        }
+        const oldValue = mapGet(valuesMap, valueId);
+        if (value2 !== oldValue) {
+          valueChanged(valueId, oldValue, value2);
+          mapSet(valuesMap, valueId, value2);
+        }
+      },
     );
-  const setValidValue = (valueId, value) => {
-    if (!collHas(valuesMap, valueId)) {
-      valueIdsChanged(valueId, 1);
-    }
-    const oldValue = mapGet(valuesMap, valueId);
-    if (value !== oldValue) {
-      valueChanged(valueId, oldValue, value);
-      mapSet(valuesMap, valueId, value);
-    }
-  };
   const getNewRowId = (tableId, reuse) => {
     const [getId] = mapGet(tablePoolFunctions, tableId);
     let rowId;
@@ -1535,14 +1667,34 @@ const createStore = () => {
     return rowId;
   };
   const getOrCreateTable = (tableId) =>
-    mapGet(tablesMap, tableId) ?? setValidTable(tableId, {});
-  const delValidTable = (tableId) => setValidTable(tableId, {});
+    mapEnsure(tablesMap, tableId, () => {
+      tableIdsChanged(tableId, 1);
+      mapSet(tablePoolFunctions, tableId, getPoolFunctions());
+      mapSet(tableCellIds, tableId, mapNew());
+      return mapNew();
+    });
+  const delValidTable = (tableId) => {
+    if (whileMutating(() => middleware[8]?.(tableId)) ?? true) {
+      return setValidTable(tableId, {}, true);
+    }
+    return mapGet(tablesMap, tableId);
+  };
   const delValidRow = (tableId, tableMap, rowId) => {
-    const [, releaseId] = mapGet(tablePoolFunctions, tableId);
-    releaseId(rowId);
-    setValidRow(tableId, tableMap, rowId, {}, true);
+    if (whileMutating(() => middleware[9]?.(tableId, rowId)) ?? true) {
+      const [, releaseId] = mapGet(tablePoolFunctions, tableId);
+      releaseId(rowId);
+      setValidRow(tableId, tableMap, rowId, {}, true);
+    }
   };
-  const delValidCell = (tableId, table, rowId, row, cellId, forceDel) => {
+  const delValidCell = (
+    tableId,
+    table,
+    rowId,
+    row,
+    cellId,
+    forceDel,
+    skipMiddleware,
+  ) => {
     const defaultCell = mapGet(
       mapGet(tablesSchemaRowCache, tableId)?.[0],
       cellId,
@@ -1550,34 +1702,44 @@ const createStore = () => {
     if (!isUndefined(defaultCell) && !forceDel) {
       return setValidCell(tableId, rowId, row, cellId, defaultCell);
     }
-    const delCell2 = (cellId2) => {
-      cellChanged(tableId, rowId, cellId2, mapGet(row, cellId2));
-      cellIdsChanged(tableId, rowId, cellId2, -1);
-      mapSet(row, cellId2);
-    };
-    if (isUndefined(defaultCell)) {
-      delCell2(cellId);
-    } else {
-      mapForEach(row, delCell2);
-    }
-    if (collIsEmpty(row)) {
-      rowIdsChanged(tableId, rowId, -1);
-      if (collIsEmpty(mapSet(table, rowId))) {
-        tableIdsChanged(tableId, -1);
-        mapSet(tablesMap, tableId);
-        mapSet(tablePoolFunctions, tableId);
-        mapSet(tableCellIds, tableId);
+    if (
+      skipMiddleware ||
+      (whileMutating(() => middleware[10]?.(tableId, rowId, cellId)) ?? true)
+    ) {
+      const delCell2 = (cellId2) => {
+        cellChanged(tableId, rowId, cellId2, mapGet(row, cellId2));
+        cellIdsChanged(tableId, rowId, cellId2, -1);
+        mapSet(row, cellId2);
+      };
+      if (isUndefined(defaultCell)) {
+        delCell2(cellId);
+      } else {
+        mapForEach(row, delCell2);
+      }
+      if (collIsEmpty(row)) {
+        rowIdsChanged(tableId, rowId, -1);
+        if (collIsEmpty(mapSet(table, rowId))) {
+          tableIdsChanged(tableId, -1);
+          mapSet(tablesMap, tableId);
+          mapSet(tablePoolFunctions, tableId);
+          mapSet(tableCellIds, tableId);
+        }
       }
     }
   };
-  const delValidValue = (valueId) => {
+  const delValidValue = (valueId, skipMiddleware) => {
     const defaultValue = mapGet(valuesDefaulted, valueId);
     if (!isUndefined(defaultValue)) {
       return setValidValue(valueId, defaultValue);
     }
-    valueChanged(valueId, mapGet(valuesMap, valueId));
-    valueIdsChanged(valueId, -1);
-    mapSet(valuesMap, valueId);
+    if (
+      skipMiddleware ||
+      (whileMutating(() => middleware[12]?.(valueId)) ?? true)
+    ) {
+      valueChanged(valueId, mapGet(valuesMap, valueId));
+      valueIdsChanged(valueId, -1);
+      mapSet(valuesMap, valueId);
+    }
   };
   const tableIdsChanged = (tableId, addedOrRemoved) =>
     idsChanged(changedTableIds, tableId, addedOrRemoved);
@@ -1622,13 +1784,13 @@ const createStore = () => {
       cellId,
       () => [oldCell, 0],
     )[1] = newCell;
-    internalListeners[3]?.(tableId, rowId, cellId, newCell);
+    internalListeners[3]?.(tableId, rowId, cellId, newCell, mutating);
   };
   const valueIdsChanged = (valueId, addedOrRemoved) =>
     idsChanged(changedValueIds, valueId, addedOrRemoved);
   const valueChanged = (valueId, oldValue, newValue) => {
     mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue;
-    internalListeners[4]?.(valueId, newValue);
+    internalListeners[4]?.(valueId, newValue, mutating);
   };
   const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
     arrayPush(
@@ -1702,15 +1864,16 @@ const createStore = () => {
       return 1;
     }
   };
+  const clonedChangedCells = (changedCells2) =>
+    mapClone(changedCells2, (map) =>
+      mapClone(map, (map2) => mapClone(map2, pairClone)),
+    );
   const callTabularListenersForChanges = (mutator) => {
-    const hasTablesNow = hasTables();
-    if (hasTablesNow != hadTables) {
-      callListeners(hasTablesListeners[mutator], void 0, hasTablesNow);
-    }
-    const emptySortedRowIdListeners = collIsEmpty(
+    const hasHasTablesListeners = !collIsEmpty(hasTablesListeners[mutator]);
+    const hasSortedRowIdListeners = !collIsEmpty(
       sortedRowIdsListeners[mutator],
     );
-    const emptyIdAndHasListeners =
+    const hasIdOrHasListeners = !(
       collIsEmpty(cellIdsListeners[mutator]) &&
       collIsEmpty(hasCellListeners[mutator]) &&
       collIsEmpty(rowIdsListeners[mutator]) &&
@@ -1718,15 +1881,17 @@ const createStore = () => {
       collIsEmpty(tableCellIdsListeners[mutator]) &&
       collIsEmpty(hasTableCellListeners[mutator]) &&
       collIsEmpty(rowCountListeners[mutator]) &&
-      emptySortedRowIdListeners &&
+      !hasSortedRowIdListeners &&
       collIsEmpty(tableIdsListeners[mutator]) &&
-      collIsEmpty(hasTableListeners[mutator]);
-    const emptyOtherListeners =
+      collIsEmpty(hasTableListeners[mutator])
+    );
+    const hasOtherListeners = !(
       collIsEmpty(cellListeners[mutator]) &&
       collIsEmpty(rowListeners[mutator]) &&
       collIsEmpty(tableListeners[mutator]) &&
-      collIsEmpty(tablesListeners[mutator]);
-    if (!emptyIdAndHasListeners || !emptyOtherListeners) {
+      collIsEmpty(tablesListeners[mutator])
+    );
+    if (hasHasTablesListeners || hasIdOrHasListeners || hasOtherListeners) {
       const changes = mutator
         ? [
             mapClone(changedTableIds),
@@ -1734,7 +1899,7 @@ const createStore = () => {
             mapClone(changedRowCount),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
-            mapClone3(changedCells),
+            clonedChangedCells(changedCells),
           ]
         : [
             changedTableIds,
@@ -1744,7 +1909,13 @@ const createStore = () => {
             changedCellIds,
             changedCells,
           ];
-      if (!emptyIdAndHasListeners) {
+      if (hasHasTablesListeners) {
+        const hasTablesNow = hasTables();
+        if (hasTablesNow != hadTables) {
+          callListeners(hasTablesListeners[mutator], void 0, hasTablesNow);
+        }
+      }
+      if (hasIdOrHasListeners) {
         callIdsAndHasListenersIfChanged(
           changes[0],
           tableIdsListeners[mutator],
@@ -1776,13 +1947,13 @@ const createStore = () => {
               hasRowListeners[mutator],
               [tableId],
             ) &&
-            !emptySortedRowIdListeners
+            hasSortedRowIdListeners
           ) {
             callListeners(sortedRowIdsListeners[mutator], [tableId, null]);
             setAdd(calledSortableTableIds, tableId);
           }
         });
-        if (!emptySortedRowIdListeners) {
+        if (hasSortedRowIdListeners) {
           collForEach(changes[5], (rows, tableId) => {
             if (!collHas(calledSortableTableIds, tableId)) {
               const sortableCellIds = setNew();
@@ -1813,7 +1984,7 @@ const createStore = () => {
           ),
         );
       }
-      if (!emptyOtherListeners) {
+      if (hasOtherListeners) {
         let tablesChanged;
         collForEach(changes[5], (rows, tableId) => {
           let tableChanged;
@@ -1850,28 +2021,31 @@ const createStore = () => {
     }
   };
   const callValuesListenersForChanges = (mutator) => {
-    const hasValuesNow = hasValues();
-    if (hasValuesNow != hadValues) {
-      callListeners(hasValuesListeners[mutator], void 0, hasValuesNow);
-    }
-    const emptyIdAndHasListeners =
-      collIsEmpty(valueIdsListeners[mutator]) &&
-      collIsEmpty(hasValueListeners[mutator]);
-    const emptyOtherListeners =
-      collIsEmpty(valueListeners[mutator]) &&
-      collIsEmpty(valuesListeners[mutator]);
-    if (!emptyIdAndHasListeners || !emptyOtherListeners) {
+    const hasHasValuesListeners = !collIsEmpty(hasValuesListeners[mutator]);
+    const hasIdOrHasListeners =
+      !collIsEmpty(valueIdsListeners[mutator]) ||
+      !collIsEmpty(hasValueListeners[mutator]);
+    const hasOtherListeners =
+      !collIsEmpty(valueListeners[mutator]) ||
+      !collIsEmpty(valuesListeners[mutator]);
+    if (hasHasValuesListeners || hasIdOrHasListeners || hasOtherListeners) {
       const changes = mutator
-        ? [mapClone(changedValueIds), mapClone(changedValues)]
+        ? [mapClone(changedValueIds), mapClone(changedValues, pairClone)]
         : [changedValueIds, changedValues];
-      if (!emptyIdAndHasListeners) {
+      if (hasHasValuesListeners) {
+        const hasValuesNow = hasValues();
+        if (hasValuesNow != hadValues) {
+          callListeners(hasValuesListeners[mutator], void 0, hasValuesNow);
+        }
+      }
+      if (hasIdOrHasListeners) {
         callIdsAndHasListenersIfChanged(
           changes[0],
           valueIdsListeners[mutator],
           hasValueListeners[mutator],
         );
       }
-      if (!emptyOtherListeners) {
+      if (hasOtherListeners) {
         let valuesChanged;
         collForEach(changes[1], ([oldValue, newValue], valueId) => {
           if (newValue !== oldValue) {
@@ -2026,14 +2200,14 @@ const createStore = () => {
         if (validateRow(tableId2, rowId2, partialRow, 1)) {
           const table = getOrCreateTable(tableId2);
           objMap(partialRow, (cell, cellId) =>
-            setCellIntoDefaultRow(tableId2, table, rowId2, cellId, cell),
+            setCellIntoNewRow(tableId2, table, rowId2, cellId, cell),
           );
         }
       },
       tableId,
       rowId,
     );
-  const setCell = (tableId, rowId, cellId, cell) =>
+  const setCell = (tableId, rowId, cellId, cell, skipMiddleware) =>
     fluentTransaction(
       (tableId2, rowId2, cellId2) =>
         ifNotUndefined(
@@ -2044,12 +2218,13 @@ const createStore = () => {
             isFunction(cell) ? cell(getCell(tableId2, rowId2, cellId2)) : cell,
           ),
           (validCell) =>
-            setCellIntoDefaultRow(
+            setCellIntoNewRow(
               tableId2,
               getOrCreateTable(tableId2),
               rowId2,
               cellId2,
               validCell,
+              skipMiddleware,
             ),
         ),
       tableId,
@@ -2068,7 +2243,7 @@ const createStore = () => {
           )
         : 0,
     );
-  const setValue = (valueId, value) =>
+  const setValue = (valueId, value, skipMiddleware) =>
     fluentTransaction(
       (valueId2) =>
         ifNotUndefined(
@@ -2076,27 +2251,40 @@ const createStore = () => {
             valueId2,
             isFunction(value) ? value(getValue(valueId2)) : value,
           ),
-          (validValue) => setValidValue(valueId2, validValue),
+          (validValue) => setValidValue(valueId2, validValue, skipMiddleware),
         ),
       valueId,
     );
   const applyChanges = (changes) =>
-    fluentTransaction(() => {
-      objMap(changes[0], (table, tableId) =>
-        isUndefined(table)
-          ? delTable(tableId)
-          : objMap(table, (row, rowId) =>
-              isUndefined(row)
-                ? delRow(tableId, rowId)
-                : objMap(row, (cell, cellId) =>
-                    setOrDelCell(store, tableId, rowId, cellId, cell),
-                  ),
-            ),
-      );
-      objMap(changes[1], (value, valueId) =>
-        setOrDelValue(store, valueId, value),
-      );
-    });
+    fluentTransaction(() =>
+      ifTransformed(
+        changes,
+        () =>
+          ifNotUndefined(
+            middleware[13],
+            (willApplyChanges) =>
+              whileMutating(() => willApplyChanges(structuredClone(changes))),
+            () => changes,
+          ),
+        (changes2) => {
+          objMap(changes2[0], (table, tableId) =>
+            isUndefined(table)
+              ? delTable(tableId)
+              : objMap(table, (row, rowId) =>
+                  isUndefined(row)
+                    ? delRow(tableId, rowId)
+                    : objMap(row, (cell, cellId) =>
+                        setOrDelCell(tableId, rowId, cellId, cell),
+                      ),
+                ),
+          );
+          objMap(changes2[1], (value, valueId) =>
+            setOrDelValue(valueId, value),
+          );
+        },
+        contentOrChangesIsEqual,
+      ),
+    );
   const setTablesJson = (tablesJson) => {
     tryCatch(() => setOrDelTables(jsonParse(tablesJson)));
     return store;
@@ -2143,7 +2331,12 @@ const createStore = () => {
       setTablesSchema(tablesSchema);
       setValuesSchema(valuesSchema);
     });
-  const delTables = () => fluentTransaction(() => setValidTables({}));
+  const delTables = () =>
+    fluentTransaction(() =>
+      (whileMutating(() => middleware[7]?.()) ?? true)
+        ? setValidTables({}, true)
+        : 0,
+    );
   const delTable = (tableId) =>
     fluentTransaction(
       (tableId2) =>
@@ -2161,7 +2354,7 @@ const createStore = () => {
       tableId,
       rowId,
     );
-  const delCell = (tableId, rowId, cellId, forceDel) =>
+  const delCell = (tableId, rowId, cellId, forceDel, skipMiddleware) =>
     fluentTransaction(
       (tableId2, rowId2, cellId2) =>
         ifNotUndefined(mapGet(tablesMap, tableId2), (tableMap) =>
@@ -2174,6 +2367,7 @@ const createStore = () => {
                   rowMap,
                   cellId2,
                   forceDel,
+                  skipMiddleware,
                 )
               : 0,
           ),
@@ -2182,11 +2376,18 @@ const createStore = () => {
       rowId,
       cellId,
     );
-  const delValues = () => fluentTransaction(() => setValidValues({}));
-  const delValue = (valueId) =>
+  const delValues = () =>
+    fluentTransaction(() =>
+      (whileMutating(() => middleware[11]?.()) ?? true)
+        ? setValidValues({}, true)
+        : 0,
+    );
+  const delValue = (valueId, skipMiddleware) =>
     fluentTransaction(
       (valueId2) =>
-        collHas(valuesMap, valueId2) ? delValidValue(valueId2) : 0,
+        collHas(valuesMap, valueId2)
+          ? delValidValue(valueId2, skipMiddleware)
+          : 0,
       valueId,
     );
   const delTablesSchema = () =>
@@ -2263,30 +2464,64 @@ const createStore = () => {
     mapToObj3(changedCellIds),
     mapToObj(changedValueIds),
   ];
+  const doDidSetRows = () => {
+    if (middleware[14]) {
+      const changedCells2 = clonedChangedCells(changedCells);
+      collForEach(changedCells2, (rows, tableId) =>
+        collForEach(rows, (cells, rowId) => {
+          if (
+            !arrayEvery(
+              collValues(cells),
+              ([oldCell, newCell]) => oldCell === newCell,
+            )
+          ) {
+            const newRow = getRow(tableId, rowId);
+            const oldRow = objMerge(newRow);
+            collForEach(cells, ([oldCell], cellId) =>
+              isUndefined(oldCell)
+                ? objDel(oldRow, cellId)
+                : (oldRow[cellId] = oldCell),
+            );
+            const didSetRow = middleware[14](tableId, rowId, oldRow, newRow);
+            if (!objIsEqual(didSetRow, newRow)) {
+              const setOrDelRow = objMap(newRow, () => void 0);
+              objMap(didSetRow, (cell, cellId) => (setOrDelRow[cellId] = cell));
+              objMap(setOrDelRow, (cell, cellId) =>
+                setOrDelCell(tableId, rowId, cellId, cell, true),
+              );
+            }
+          }
+        }),
+      );
+    }
+  };
   const finishTransaction = (doRollback) => {
     if (transactions > 0) {
       transactions--;
       if (transactions == 0) {
         transactions = 1;
-        callInvalidCellListeners(1);
-        if (!collIsEmpty(changedCells)) {
-          callTabularListenersForChanges(1);
-        }
-        callInvalidValueListeners(1);
-        if (!collIsEmpty(changedValues)) {
-          callValuesListenersForChanges(1);
-        }
+        whileMutating(() => {
+          callInvalidCellListeners(1);
+          if (!collIsEmpty(changedCells)) {
+            callTabularListenersForChanges(1);
+            doDidSetRows();
+          }
+          callInvalidValueListeners(1);
+          if (!collIsEmpty(changedValues)) {
+            callValuesListenersForChanges(1);
+          }
+        });
         if (doRollback?.(store)) {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
-                setOrDelCell(store, tableId, rowId, cellId, oldCell),
+                setOrDelCell(tableId, rowId, cellId, oldCell, true),
               ),
             ),
           );
           collClear(changedCells);
           collForEach(changedValues, ([oldValue], valueId) =>
-            setOrDelValue(store, valueId, oldValue),
+            setOrDelValue(valueId, oldValue, true),
           );
           collClear(changedValues);
         }
@@ -2413,6 +2648,40 @@ const createStore = () => {
       collSize2(startTransactionListeners) +
       pairCollSize2(finishTransactionListeners),
   });
+  const setMiddleware = (
+    willSetContent,
+    willSetTables,
+    willSetTable,
+    willSetRow,
+    willSetCell,
+    willSetValues,
+    willSetValue,
+    willDelTables,
+    willDelTable,
+    willDelRow,
+    willDelCell,
+    willDelValues,
+    willDelValue,
+    willApplyChanges,
+    didSetRow,
+  ) =>
+    (middleware = [
+      willSetContent,
+      willSetTables,
+      willSetTable,
+      willSetRow,
+      willSetCell,
+      willSetValues,
+      willSetValue,
+      willDelTables,
+      willDelTable,
+      willDelRow,
+      willDelCell,
+      willDelValues,
+      willDelValue,
+      willApplyChanges,
+      didSetRow,
+    ]);
   const setInternalListeners = (
     preStartTransaction,
     preFinishTransaction,
@@ -2506,6 +2775,9 @@ const createStore = () => {
     addListener,
     callListeners,
     setInternalListeners,
+    setMiddleware,
+    setOrDelCell,
+    setOrDelValue,
   };
   objMap(
     {
@@ -2642,6 +2914,7 @@ const createMergeableStore = (uniqueId, getNow) => {
   let listeningToRawStoreChanges = 1;
   let contentStampMap = newContentStampMap();
   let defaultingContent = 0;
+  let mutated = 0;
   const touchedCells = mapNew();
   const touchedValues = setNew();
   const [getNextHlc, seenHlc] = getHlcFunctions(uniqueId, getNow);
@@ -2768,12 +3041,15 @@ const createMergeableStore = (uniqueId, getNow) => {
     collClear(touchedCells);
     collClear(touchedValues);
   };
-  const cellChanged = (tableId, rowId, cellId, newCell) => {
+  const cellChanged = (tableId, rowId, cellId, newCell, mutating) => {
     setAdd(
       mapEnsure(mapEnsure(touchedCells, tableId, mapNew), rowId, setNew),
       cellId,
     );
-    if (listeningToRawStoreChanges) {
+    if (listeningToRawStoreChanges || mutating) {
+      if (mutating) {
+        mutated = 1;
+      }
       mergeContentOrChanges([
         [
           {
@@ -2796,9 +3072,12 @@ const createMergeableStore = (uniqueId, getNow) => {
       ]);
     }
   };
-  const valueChanged = (valueId, newValue) => {
+  const valueChanged = (valueId, newValue, mutating) => {
     setAdd(touchedValues, valueId);
-    if (listeningToRawStoreChanges) {
+    if (listeningToRawStoreChanges || mutating) {
+      if (mutating) {
+        mutated = 1;
+      }
       mergeContentOrChanges([
         [{}],
         [
@@ -3016,6 +3295,11 @@ const createMergeableStore = (uniqueId, getNow) => {
     mergeableStore2.applyMergeableChanges(mergeableChanges);
     return applyMergeableChanges(mergeableChanges2);
   };
+  const hadMutated = () => {
+    const result = mutated;
+    mutated = 0;
+    return result;
+  };
   const mergeableStore = {
     getMergeableContent,
     getMergeableContentHashes,
@@ -3032,6 +3316,8 @@ const createMergeableStore = (uniqueId, getNow) => {
     getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
+    // only used internally by other modules
+    hadMutated,
   };
   store.setInternalListeners(
     preStartTransaction,
@@ -3048,7 +3334,8 @@ const createMergeableStore = (uniqueId, getNow) => {
         strStartsWith(name, DEL) ||
         strStartsWith(name, 'apply') ||
         strEndsWith(name, TRANSACTION) ||
-        name == 'call' + LISTENER
+        name == 'call' + LISTENER ||
+        name == 'use'
           ? (...args) => {
               method(...args);
               return mergeableStore;
@@ -3241,6 +3528,136 @@ const createMetrics = getCreateFunction((store) => {
   return objFreeze(metrics);
 });
 
+const reduceCallbacks = (callbacks, thing, ...ids) =>
+  arrayReduce(
+    callbacks,
+    (current, callback) =>
+      isUndefined(current) ? current : callback(...ids, current),
+    thing,
+  );
+const everyCallback = (callbacks, ...ids) =>
+  arrayEvery(callbacks, (callback) => callback(...ids));
+const createMiddleware = getCreateFunction((store) => {
+  const fluent = (actions) => {
+    actions();
+    return middleware;
+  };
+  const addCallback = (callbacks) => (callback) =>
+    fluent(() => arrayPush(callbacks, callback));
+  const willSetContentCallbacks = [];
+  const willSetTablesCallbacks = [];
+  const willSetTableCallbacks = [];
+  const willSetRowCallbacks = [];
+  const willSetCellCallbacks = [];
+  const willSetValuesCallbacks = [];
+  const willSetValueCallbacks = [];
+  const willDelTablesCallbacks = [];
+  const willDelTableCallbacks = [];
+  const willDelRowCallbacks = [];
+  const willDelCellCallbacks = [];
+  const willDelValuesCallbacks = [];
+  const willDelValueCallbacks = [];
+  const willApplyChangesCallbacks = [];
+  const didSetRowCallbacksMap = mapNew();
+  const willSetContent = (content) =>
+    reduceCallbacks(willSetContentCallbacks, content);
+  const willSetTables = (tables) =>
+    reduceCallbacks(willSetTablesCallbacks, tables);
+  const willSetTable = (tableId, table) =>
+    reduceCallbacks(willSetTableCallbacks, table, tableId);
+  const willSetRow = (tableId, rowId, row) =>
+    reduceCallbacks(willSetRowCallbacks, row, tableId, rowId);
+  const willSetCell = (tableId, rowId, cellId, cell) =>
+    reduceCallbacks(willSetCellCallbacks, cell, tableId, rowId, cellId);
+  const willSetValues = (values) =>
+    reduceCallbacks(willSetValuesCallbacks, values);
+  const willSetValue = (valueId, value) =>
+    reduceCallbacks(willSetValueCallbacks, value, valueId);
+  const willDelTables = () => everyCallback(willDelTablesCallbacks);
+  const willDelTable = (tableId) =>
+    everyCallback(willDelTableCallbacks, tableId);
+  const willDelRow = (tableId, rowId) =>
+    everyCallback(willDelRowCallbacks, tableId, rowId);
+  const willDelCell = (tableId, rowId, cellId) =>
+    everyCallback(willDelCellCallbacks, tableId, rowId, cellId);
+  const willDelValues = () => everyCallback(willDelValuesCallbacks);
+  const willDelValue = (valueId) =>
+    everyCallback(willDelValueCallbacks, valueId);
+  const willApplyChanges = (changes) =>
+    reduceCallbacks(willApplyChangesCallbacks, changes);
+  const didSetRow = (tableId, rowId, oldRow, newRow) =>
+    ifNotUndefined(
+      mapGet(didSetRowCallbacksMap, tableId),
+      (callbacks) =>
+        arrayReduce(
+          callbacks,
+          (current, callback) => callback(tableId, rowId, oldRow, current),
+          newRow,
+        ),
+      () => newRow,
+    );
+  const getStore = () => store;
+  const addWillSetContentCallback = addCallback(willSetContentCallbacks);
+  const addWillSetTablesCallback = addCallback(willSetTablesCallbacks);
+  const addWillSetTableCallback = addCallback(willSetTableCallbacks);
+  const addWillSetRowCallback = addCallback(willSetRowCallbacks);
+  const addWillSetCellCallback = addCallback(willSetCellCallbacks);
+  const addWillSetValuesCallback = addCallback(willSetValuesCallbacks);
+  const addWillSetValueCallback = addCallback(willSetValueCallbacks);
+  const addWillDelTablesCallback = addCallback(willDelTablesCallbacks);
+  const addWillDelTableCallback = addCallback(willDelTableCallbacks);
+  const addWillDelRowCallback = addCallback(willDelRowCallbacks);
+  const addWillDelCellCallback = addCallback(willDelCellCallbacks);
+  const addWillDelValuesCallback = addCallback(willDelValuesCallbacks);
+  const addWillDelValueCallback = addCallback(willDelValueCallbacks);
+  const addWillApplyChangesCallback = addCallback(willApplyChangesCallbacks);
+  const addDidSetRowCallback = (tableId, callback) =>
+    fluent(() =>
+      arrayPush(
+        mapEnsure(didSetRowCallbacksMap, tableId, () => []),
+        callback,
+      ),
+    );
+  const destroy = () => {};
+  const middleware = objFreeze({
+    getStore,
+    addWillSetContentCallback,
+    addWillSetTablesCallback,
+    addWillSetTableCallback,
+    addWillSetRowCallback,
+    addWillSetCellCallback,
+    addWillSetValuesCallback,
+    addWillSetValueCallback,
+    addWillDelTablesCallback,
+    addWillDelTableCallback,
+    addWillDelRowCallback,
+    addWillDelCellCallback,
+    addWillDelValuesCallback,
+    addWillDelValueCallback,
+    addWillApplyChangesCallback,
+    addDidSetRowCallback,
+    destroy,
+  });
+  store.setMiddleware(
+    willSetContent,
+    willSetTables,
+    willSetTable,
+    willSetRow,
+    willSetCell,
+    willSetValues,
+    willSetValue,
+    willDelTables,
+    willDelTable,
+    willDelRow,
+    willDelCell,
+    willDelValues,
+    willDelValue,
+    willApplyChanges,
+    didSetRow,
+  );
+  return middleware;
+});
+
 const createQueries = getCreateFunction((store) => {
   const createStore = store.createStore;
   const preStore = createStore();
@@ -3569,8 +3986,7 @@ const createQueries = getCreateFunction((store) => {
       selectJoinWhereStore.transaction(() =>
         arrayEvery(wheres, (where2) => where2(getTableCell))
           ? mapForEach(selects, (asCellId, tableCellGetter) =>
-              setOrDelCell(
-                selectJoinWhereStore,
+              selectJoinWhereStore.setOrDelCell(
                 queryId,
                 rootRowId,
                 asCellId,
@@ -3975,6 +4391,7 @@ export {
   createIndexes,
   createMergeableStore,
   createMetrics,
+  createMiddleware,
   createQueries,
   createRelationships,
   createStore,