tinybase 8.0.0-beta.0 → 8.0.0-beta.1

package/store/with-schemas/index.js

@@ -27,6 +27,7 @@ const id = (key) => EMPTY_STRING + key;
 
 const getIfNotFunction = (predicate) => (value, then, otherwise) =>
   predicate(value) ? otherwise?.() : then(value);
+const GLOBAL = globalThis;
 const isFiniteNumber = isFinite;
 const isInstanceOf = (thing, cls) => thing instanceof cls;
 const isNullish = (thing) => thing == null;
@@ -40,6 +41,7 @@ const isArray = (thing) => Array.isArray(thing);
 const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
 const size = (arrayOrString) => arrayOrString.length;
 const test = (regex, subject) => regex.test(subject);
+const structuredClone = GLOBAL.structuredClone;
 const tryCatch = async (action, then1, then2) => {
   try {
     return await action();
@@ -71,12 +73,6 @@ const getCellOrValueType = (cellOrValue) => {
     ? type
     : void 0;
 };
-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);
@@ -122,6 +118,26 @@ const objMap = (obj, cb) =>
   objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+/* istanbul ignore next */
+const objIsEqual = (
+  obj1,
+  obj2,
+  isEqual = (value1, value2) => value1 === value2,
+) => {
+  const entries1 = objEntries(obj1);
+  return (
+    size(entries1) === objSize(obj2) &&
+    arrayEvery(entries1, ([index, value1]) =>
+      isObject(value1)
+        ? /* istanbul ignore next */
+          isObject(obj2[index])
+          ? objIsEqual(obj2[index], value1)
+          : false
+        : isEqual(value1, obj2[index]),
+    )
+  );
+};
 const objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
   if (
     isNullish(obj) ||
@@ -140,31 +156,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)) {
@@ -174,27 +191,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)(
@@ -333,13 +350,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();
@@ -385,6 +406,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),
@@ -572,82 +606,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),
+      () =>
+        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) => {
-    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) =>
+  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;
@@ -657,14 +803,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,
@@ -672,34 +838,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);
@@ -744,13 +920,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(
@@ -825,14 +1001,11 @@ const createStore = () => {
     }
   };
   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]) &&
@@ -840,15 +1013,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),
@@ -856,7 +1031,9 @@ const createStore = () => {
             mapClone(changedRowCount),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
-            mapClone3(changedCells),
+            mapClone(changedCells, (map) =>
+              mapClone(map, (map2) => mapClone(map2, pairClone)),
+            ),
           ]
         : [
             changedTableIds,
@@ -866,7 +1043,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],
@@ -898,13 +1081,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();
@@ -935,7 +1118,7 @@ const createStore = () => {
           ),
         );
       }
-      if (!emptyOtherListeners) {
+      if (hasOtherListeners) {
         let tablesChanged;
         collForEach(changes[5], (rows, tableId) => {
           let tableChanged;
@@ -972,28 +1155,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) {
@@ -1148,14 +1334,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(
@@ -1166,12 +1352,13 @@ const createStore = () => {
             isFunction(cell) ? cell(getCell(tableId2, rowId2, cellId2)) : cell,
           ),
           (validCell) =>
-            setCellIntoDefaultRow(
+            setCellIntoNewRow(
               tableId2,
               getOrCreateTable(tableId2),
               rowId2,
               cellId2,
               validCell,
+              skipMiddleware,
             ),
         ),
       tableId,
@@ -1190,7 +1377,7 @@ const createStore = () => {
           )
         : 0,
     );
-  const setValue = (valueId, value) =>
+  const setValue = (valueId, value, skipMiddleware) =>
     fluentTransaction(
       (valueId2) =>
         ifNotUndefined(
@@ -1198,27 +1385,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;
@@ -1265,7 +1465,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) =>
@@ -1283,7 +1488,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) =>
@@ -1296,6 +1501,7 @@ const createStore = () => {
                   rowMap,
                   cellId2,
                   forceDel,
+                  skipMiddleware,
                 )
               : 0,
           ),
@@ -1304,11 +1510,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 = () =>
@@ -1390,25 +1603,27 @@ const createStore = () => {
       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);
+          }
+          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);
         }
@@ -1535,6 +1750,38 @@ const createStore = () => {
       collSize2(startTransactionListeners) +
       pairCollSize2(finishTransactionListeners),
   });
+  const setMiddleware = (
+    willSetContent,
+    willSetTables,
+    willSetTable,
+    willSetRow,
+    willSetCell,
+    willSetValues,
+    willSetValue,
+    willDelTables,
+    willDelTable,
+    willDelRow,
+    willDelCell,
+    willDelValues,
+    willDelValue,
+    willApplyChanges,
+  ) =>
+    (middleware = [
+      willSetContent,
+      willSetTables,
+      willSetTable,
+      willSetRow,
+      willSetCell,
+      willSetValues,
+      willSetValue,
+      willDelTables,
+      willDelTable,
+      willDelRow,
+      willDelCell,
+      willDelValues,
+      willDelValue,
+      willApplyChanges,
+    ]);
   const setInternalListeners = (
     preStartTransaction,
     preFinishTransaction,
@@ -1628,6 +1875,9 @@ const createStore = () => {
     addListener,
     callListeners,
     setInternalListeners,
+    setMiddleware,
+    setOrDelCell,
+    setOrDelValue,
   };
   objMap(
     {