tinybase 8.0.0-beta.1 → 8.0.0-beta.3

package/with-schemas/index.js

@@ -4,6 +4,8 @@ const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
 const NUMBER = getTypeOf(0);
 const FUNCTION = getTypeOf(getTypeOf);
+const OBJECT = 'object';
+const ARRAY = 'array';
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
@@ -33,6 +35,7 @@ const VALUE = 'Value';
 const VALUES = VALUE + 's';
 const VALUE_IDS = VALUE + IDS;
 const TRANSACTION = 'Transaction';
+const JSON_PREFIX = '\uFFFD';
 const id = (key) => EMPTY_STRING + key;
 const strStartsWith = (str, prefix) => str.startsWith(prefix);
 const strEndsWith = (str, suffix) => str.endsWith(suffix);
@@ -131,6 +134,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) => {
@@ -559,18 +563,12 @@ const createCheckpoints = getCreateFunction(
         collForEach(cellsDelta2, (table, tableId) =>
           collForEach(table, (row, rowId) =>
             collForEach(row, (oldNew, cellId) =>
-              store.setOrDelCell(
-                tableId,
-                rowId,
-                cellId,
-                oldNew[oldOrNew],
-                true,
-              ),
+              store._[5](tableId, rowId, cellId, oldNew[oldOrNew], true),
             ),
           ),
         );
         collForEach(valuesDelta2, (oldNew, valueId) =>
-          store.setOrDelValue(valueId, oldNew[oldOrNew], true),
+          store._[6](valueId, oldNew[oldOrNew], true),
         );
       });
       listening = 1;
@@ -1160,6 +1158,12 @@ const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
     return NULL;
   }
+  if (isArray(cellOrValue)) {
+    return ARRAY;
+  }
+  if (isObject(cellOrValue)) {
+    return OBJECT;
+  }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||
     (type == NUMBER && isFiniteNumber(cellOrValue))
@@ -1168,9 +1172,14 @@ const getCellOrValueType = (cellOrValue) => {
 };
 const isCellOrValueOrUndefined = (cellOrValue) =>
   isUndefined(cellOrValue) || !isUndefined(getCellOrValueType(cellOrValue));
+const isJsonType = (type) => type == OBJECT || type == ARRAY;
+const encodeIfJson = (value) =>
+  isObject(value) || isArray(value) ? JSON_PREFIX + jsonString(value) : value;
+const isEncodedJson = (value) => isString(value) && value[0] == JSON_PREFIX;
+const decodeIfJson = (raw, _id, encoded) =>
+  !encoded && isEncodedJson(raw) ? jsonParse(slice(raw, 1)) : raw;
 
 const stampClone = ([value, hlc]) => stampNew(value, hlc);
-const stampCloneWithHash = ([value, hlc, hash]) => [value, hlc, hash];
 const stampNew = (value, hlc) => (hlc ? [value, hlc] : [value]);
 const stampNewWithHash = (value, hlc, hash) => [value, hlc, hash];
 const getStampHash = (stamp) => stamp[2];
@@ -1187,10 +1196,11 @@ const stampUpdate = (stamp, hlc, hash) => {
 };
 const stampNewObj = (hlc = EMPTY_STRING) => stampNew(objNew(), hlc);
 const stampNewMap = (hlc = EMPTY_STRING) => [mapNew(), hlc, 0];
-const stampMapToObjWithHash = (
-  [map, hlc, hash],
-  mapper = stampCloneWithHash,
-) => [mapToObj(map, mapper), hlc, hash];
+const stampMapToObjWithHash = ([map, hlc, hash], mapper) => [
+  mapToObj(map, mapper),
+  hlc,
+  hash,
+];
 const stampMapToObjWithoutHash = ([map, hlc], mapper = stampClone) =>
   stampNew(mapToObj(map, mapper), hlc);
 const stampValidate = (stamp, validateThing) =>
@@ -1297,15 +1307,19 @@ const createStore = () => {
       return false;
     }
     const type = schema[TYPE];
-    if (!isTypeStringOrBoolean(type) && type != NUMBER) {
+    if (!isTypeStringOrBoolean(type) && type != NUMBER && !isJsonType(type)) {
       return false;
     }
     const defaultValue = schema[DEFAULT];
     if (isNull(defaultValue) && !schema[ALLOW_NULL]) {
       return false;
     }
-    if (!isNull(defaultValue) && getCellOrValueType(defaultValue) != type) {
-      objDel(schema, DEFAULT);
+    if (!isNull(defaultValue)) {
+      if (getCellOrValueType(defaultValue) != type) {
+        objDel(schema, DEFAULT);
+      } else {
+        schema[DEFAULT] = encodeIfJson(defaultValue);
+      }
     }
     return true;
   };
@@ -1345,20 +1359,22 @@ const createStore = () => {
               ? cellSchema[ALLOW_NULL]
                 ? cell
                 : cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])
-              : getCellOrValueType(cell) == cellSchema[TYPE]
-                ? cell
-                : cellInvalid(
-                    tableId,
-                    rowId,
-                    cellId,
-                    cell,
-                    cellSchema[DEFAULT],
-                  ),
+              : getCellOrValueType(cell) === cellSchema[TYPE]
+                ? encodeIfJson(cell)
+                : isJsonType(cellSchema[TYPE]) && isEncodedJson(cell)
+                  ? cell
+                  : cellInvalid(
+                      tableId,
+                      rowId,
+                      cellId,
+                      cell,
+                      cellSchema[DEFAULT],
+                    ),
           () => cellInvalid(tableId, rowId, cellId, cell),
         )
       : isUndefined(getCellOrValueType(cell))
         ? cellInvalid(tableId, rowId, cellId, cell)
-        : cell;
+        : encodeIfJson(cell);
   const validateValues = (values, skipDefaults) =>
     objValidate(
       skipDefaults ? values : addDefaultsToValues(values),
@@ -1382,14 +1398,16 @@ const createStore = () => {
               ? valueSchema[ALLOW_NULL]
                 ? value
                 : valueInvalid(valueId, value, valueSchema[DEFAULT])
-              : getCellOrValueType(value) == valueSchema[TYPE]
-                ? value
-                : valueInvalid(valueId, value, valueSchema[DEFAULT]),
+              : getCellOrValueType(value) === valueSchema[TYPE]
+                ? encodeIfJson(value)
+                : isJsonType(valueSchema[TYPE]) && isEncodedJson(value)
+                  ? value
+                  : valueInvalid(valueId, value, valueSchema[DEFAULT]),
           () => valueInvalid(valueId, value),
         )
       : isUndefined(getCellOrValueType(value))
         ? valueInvalid(valueId, value)
-        : value;
+        : encodeIfJson(value);
   const addDefaultsToRow = (row, tableId, rowId) => {
     ifNotUndefined(
       mapGet(tablesSchemaRowCache, tableId),
@@ -1812,13 +1830,21 @@ const createStore = () => {
   const getCellChange = (tableId, rowId, cellId) =>
     ifNotUndefined(
       mapGet(mapGet(mapGet(changedCells, tableId), rowId), cellId),
-      ([oldCell, newCell]) => [true, oldCell, newCell],
+      ([oldCell, newCell]) => [
+        true,
+        decodeIfJson(oldCell),
+        decodeIfJson(newCell),
+      ],
       () => [false, ...pairNew(getCell(tableId, rowId, cellId))],
     );
   const getValueChange = (valueId) =>
     ifNotUndefined(
       mapGet(changedValues, valueId),
-      ([oldValue, newValue]) => [true, oldValue, newValue],
+      ([oldValue, newValue]) => [
+        true,
+        decodeIfJson(oldValue),
+        decodeIfJson(newValue),
+      ],
       () => [false, ...pairNew(getValue(valueId))],
     );
   const callInvalidCellListeners = (mutator) =>
@@ -1863,6 +1889,10 @@ const createStore = () => {
       return 1;
     }
   };
+  const clonedChangedCells = (changedCells2) =>
+    mapClone(changedCells2, (map) =>
+      mapClone(map, (map2) => mapClone(map2, pairClone)),
+    );
   const callTabularListenersForChanges = (mutator) => {
     const hasHasTablesListeners = !collIsEmpty(hasTablesListeners[mutator]);
     const hasSortedRowIdListeners = !collIsEmpty(
@@ -1894,9 +1924,7 @@ const createStore = () => {
             mapClone(changedRowCount),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
-            mapClone(changedCells, (map) =>
-              mapClone(map, (map2) => mapClone(map2, pairClone)),
-            ),
+            clonedChangedCells(changedCells),
           ]
         : [
             changedTableIds,
@@ -1992,8 +2020,8 @@ const createStore = () => {
                 callListeners(
                   cellListeners[mutator],
                   [tableId, rowId, cellId],
-                  newCell,
-                  oldCell,
+                  decodeIfJson(newCell),
+                  decodeIfJson(oldCell),
                   getCellChange,
                 );
                 tablesChanged = tableChanged = rowChanged = 1;
@@ -2049,8 +2077,8 @@ const createStore = () => {
             callListeners(
               valueListeners[mutator],
               [valueId],
-              newValue,
-              oldValue,
+              decodeIfJson(newValue),
+              decodeIfJson(oldValue),
               getValueChange,
             );
             valuesChanged = 1;
@@ -2087,10 +2115,42 @@ const createStore = () => {
       [getTableIds],
     );
   };
+  const getTransactionChangesImpl = (encoded = false) => [
+    mapToObj(
+      changedCells,
+      (table, tableId) =>
+        mapGet(changedTableIds, tableId) === -1
+          ? void 0
+          : mapToObj(
+              table,
+              (row, rowId) =>
+                mapGet(mapGet(changedRowIds, tableId), rowId) === -1
+                  ? void 0
+                  : mapToObj(
+                      row,
+                      ([, newCell]) =>
+                        decodeIfJson(newCell, EMPTY_STRING, encoded),
+                      (changedCell) => pairIsEqual(changedCell),
+                    ),
+              collIsEmpty,
+              objIsEmpty,
+            ),
+      collIsEmpty,
+      objIsEmpty,
+    ),
+    mapToObj(
+      changedValues,
+      ([, newValue]) => decodeIfJson(newValue, EMPTY_STRING, encoded),
+      (changedValue) => pairIsEqual(changedValue),
+    ),
+    1,
+  ];
   const getContent = () => [getTables(), getValues()];
-  const getTables = () => mapToObj3(tablesMap);
+  const getEncodedContent = () => [mapToObj3(tablesMap), mapToObj(valuesMap)];
+  const getTables = () => mapToObj3(tablesMap, decodeIfJson);
   const getTableIds = () => mapKeys(tablesMap);
-  const getTable = (tableId) => mapToObj2(mapGet(tablesMap, id(tableId)));
+  const getTable = (tableId) =>
+    mapToObj2(mapGet(tablesMap, id(tableId)), decodeIfJson);
   const getTableCellIds = (tableId) =>
     mapKeys(mapGet(tableCellIds, id(tableId)));
   const getRowCount = (tableId) => collSize(mapGet(tablesMap, id(tableId)));
@@ -2126,14 +2186,16 @@ const createStore = () => {
           ([, rowId]) => rowId,
         );
   const getRow = (tableId, rowId) =>
-    mapToObj(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));
+    mapToObj(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), decodeIfJson);
   const getCellIds = (tableId, rowId) =>
     mapKeys(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));
   const getCell = (tableId, rowId, cellId) =>
-    mapGet(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));
-  const getValues = () => mapToObj(valuesMap);
+    decodeIfJson(
+      mapGet(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId)),
+    );
+  const getValues = () => mapToObj(valuesMap, decodeIfJson);
   const getValueIds = () => mapKeys(valuesMap);
-  const getValue = (valueId) => mapGet(valuesMap, id(valueId));
+  const getValue = (valueId) => decodeIfJson(mapGet(valuesMap, id(valueId)));
   const hasTables = () => !collIsEmpty(tablesMap);
   const hasTable = (tableId) => collHas(tablesMap, id(tableId));
   const hasTableCell = (tableId, cellId) =>
@@ -2420,35 +2482,8 @@ const createStore = () => {
     }
     return store;
   };
-  const getTransactionChanges = () => [
-    mapToObj(
-      changedCells,
-      (table, tableId) =>
-        mapGet(changedTableIds, tableId) === -1
-          ? void 0
-          : mapToObj(
-              table,
-              (row, rowId) =>
-                mapGet(mapGet(changedRowIds, tableId), rowId) === -1
-                  ? void 0
-                  : mapToObj(
-                      row,
-                      ([, newCell]) => newCell,
-                      (changedCell) => pairIsEqual(changedCell),
-                    ),
-              collIsEmpty,
-              objIsEmpty,
-            ),
-      collIsEmpty,
-      objIsEmpty,
-    ),
-    mapToObj(
-      changedValues,
-      ([, newValue]) => newValue,
-      (changedValue) => pairIsEqual(changedValue),
-    ),
-    1,
-  ];
+  const getTransactionChanges = () => getTransactionChangesImpl();
+  const getEncodedTransactionChanges = () => getTransactionChangesImpl(true);
   const getTransactionLog = () => [
     !collIsEmpty(changedCells),
     !collIsEmpty(changedValues),
@@ -2461,6 +2496,37 @@ 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--;
@@ -2470,6 +2536,7 @@ const createStore = () => {
           callInvalidCellListeners(1);
           if (!collIsEmpty(changedCells)) {
             callTabularListenersForChanges(1);
+            doDidSetRows();
           }
           callInvalidValueListeners(1);
           if (!collIsEmpty(changedValues)) {
@@ -2530,7 +2597,9 @@ const createStore = () => {
       tableCallback(tableId, (rowCallback) =>
         collForEach(tableMap, (rowMap, rowId) =>
           rowCallback(rowId, (cellCallback) =>
-            mapForEach(rowMap, cellCallback),
+            mapForEach(rowMap, (cellId, cell) =>
+              cellCallback(cellId, decodeIfJson(cell)),
+            ),
           ),
         ),
       ),
@@ -2539,11 +2608,21 @@ const createStore = () => {
     mapForEach(mapGet(tableCellIds, id(tableId)), tableCellCallback);
   const forEachRow = (tableId, rowCallback) =>
     collForEach(mapGet(tablesMap, id(tableId)), (rowMap, rowId) =>
-      rowCallback(rowId, (cellCallback) => mapForEach(rowMap, cellCallback)),
+      rowCallback(rowId, (cellCallback) =>
+        mapForEach(rowMap, (cellId, cell) =>
+          cellCallback(cellId, decodeIfJson(cell)),
+        ),
+      ),
     );
   const forEachCell = (tableId, rowId, cellCallback) =>
-    mapForEach(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), cellCallback);
-  const forEachValue = (valueCallback) => mapForEach(valuesMap, valueCallback);
+    mapForEach(
+      mapGet(mapGet(tablesMap, id(tableId)), id(rowId)),
+      (cellId, cell) => cellCallback(cellId, decodeIfJson(cell)),
+    );
+  const forEachValue = (valueCallback) =>
+    mapForEach(valuesMap, (valueId, value) =>
+      valueCallback(valueId, decodeIfJson(value)),
+    );
   const addSortedRowIdsListener = (
     tableIdOrArgs,
     cellIdOrListener,
@@ -2628,6 +2707,7 @@ const createStore = () => {
     willDelValues,
     willDelValue,
     willApplyChanges,
+    didSetRow,
   ) =>
     (middleware = [
       willSetContent,
@@ -2644,6 +2724,7 @@ const createStore = () => {
       willDelValues,
       willDelValue,
       willApplyChanges,
+      didSetRow,
     ]);
   const setInternalListeners = (
     preStartTransaction,
@@ -2733,14 +2814,17 @@ const createStore = () => {
     delListener,
     getListenerStats,
     isMergeable: () => false,
-    // only used internally by other modules
-    createStore,
-    addListener,
-    callListeners,
-    setInternalListeners,
-    setMiddleware,
-    setOrDelCell,
-    setOrDelValue,
+    _: [
+      createStore,
+      addListener,
+      callListeners,
+      setInternalListeners,
+      setMiddleware,
+      setOrDelCell,
+      setOrDelValue,
+      getEncodedContent,
+      getEncodedTransactionChanges,
+    ],
   };
   objMap(
     {
@@ -3055,14 +3139,78 @@ const createMergeableStore = (uniqueId, getNow) => {
       ]);
     }
   };
-  const getMergeableContent = () => [
+  const getMergeableContentImpl = (encoded = false) => [
     stampMapToObjWithHash(contentStampMap[0], (tableStampMap) =>
       stampMapToObjWithHash(tableStampMap, (rowStampMap) =>
-        stampMapToObjWithHash(rowStampMap),
+        stampMapToObjWithHash(rowStampMap, ([cell, hlc, hash]) => [
+          decodeIfJson(cell, EMPTY_STRING, encoded),
+          hlc,
+          hash,
+        ]),
       ),
     ),
-    stampMapToObjWithHash(contentStampMap[1]),
+    stampMapToObjWithHash(contentStampMap[1], ([value, hlc, hash]) => [
+      decodeIfJson(value, EMPTY_STRING, encoded),
+      hlc,
+      hash,
+    ]),
   ];
+  const getTransactionMergeableChangesImpl = (withHashes, encoded = false) => {
+    const [
+      [tableStampMaps, tablesHlc, tablesHash],
+      [valueStampMaps, valuesHlc, valuesHash],
+    ] = contentStampMap;
+    const newStamp = withHashes ? stampNewWithHash : stampNew;
+    const tablesObj = {};
+    collForEach(touchedCells, (touchedTable, tableId) =>
+      ifNotUndefined(
+        mapGet(tableStampMaps, tableId),
+        ([rowStampMaps, tableHlc, tableHash]) => {
+          const tableObj = {};
+          collForEach(touchedTable, (touchedRow, rowId) =>
+            ifNotUndefined(
+              mapGet(rowStampMaps, rowId),
+              ([cellStampMaps, rowHlc, rowHash]) => {
+                const rowObj = {};
+                collForEach(touchedRow, (cellId) => {
+                  ifNotUndefined(
+                    mapGet(cellStampMaps, cellId),
+                    ([cell, time, hash]) =>
+                      (rowObj[cellId] = newStamp(
+                        encoded ? cell : decodeIfJson(cell),
+                        time,
+                        hash,
+                      )),
+                  );
+                });
+                tableObj[rowId] = newStamp(rowObj, rowHlc, rowHash);
+              },
+            ),
+          );
+          tablesObj[tableId] = newStamp(tableObj, tableHlc, tableHash);
+        },
+      ),
+    );
+    const valuesObj = {};
+    collForEach(touchedValues, (valueId) =>
+      ifNotUndefined(
+        mapGet(valueStampMaps, valueId),
+        ([value, time, hash]) =>
+          (valuesObj[valueId] = newStamp(
+            encoded ? value : decodeIfJson(value),
+            time,
+            hash,
+          )),
+      ),
+    );
+    return [
+      newStamp(tablesObj, tablesHlc, tablesHash),
+      newStamp(valuesObj, valuesHlc, valuesHash),
+      1,
+    ];
+  };
+  const getMergeableContent = () => getMergeableContentImpl();
+  const getEncodedMergeableContent = () => getMergeableContentImpl(true);
   const getMergeableContentHashes = () => [
     contentStampMap[0][2],
     contentStampMap[1][2],
@@ -3202,52 +3350,10 @@ const createMergeableStore = (uniqueId, getNow) => {
     });
     return mergeableStore;
   };
-  const getTransactionMergeableChanges = (withHashes = false) => {
-    const [
-      [tableStampMaps, tablesHlc, tablesHash],
-      [valueStampMaps, valuesHlc, valuesHash],
-    ] = contentStampMap;
-    const newStamp = withHashes ? stampNewWithHash : stampNew;
-    const tablesObj = {};
-    collForEach(touchedCells, (touchedTable, tableId) =>
-      ifNotUndefined(
-        mapGet(tableStampMaps, tableId),
-        ([rowStampMaps, tableHlc, tableHash]) => {
-          const tableObj = {};
-          collForEach(touchedTable, (touchedRow, rowId) =>
-            ifNotUndefined(
-              mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowHlc, rowHash]) => {
-                const rowObj = {};
-                collForEach(touchedRow, (cellId) => {
-                  ifNotUndefined(
-                    mapGet(cellStampMaps, cellId),
-                    ([cell, time, hash]) =>
-                      (rowObj[cellId] = newStamp(cell, time, hash)),
-                  );
-                });
-                tableObj[rowId] = newStamp(rowObj, rowHlc, rowHash);
-              },
-            ),
-          );
-          tablesObj[tableId] = newStamp(tableObj, tableHlc, tableHash);
-        },
-      ),
-    );
-    const valuesObj = {};
-    collForEach(touchedValues, (valueId) =>
-      ifNotUndefined(
-        mapGet(valueStampMaps, valueId),
-        ([value, time, hash]) =>
-          (valuesObj[valueId] = newStamp(value, time, hash)),
-      ),
-    );
-    return [
-      newStamp(tablesObj, tablesHlc, tablesHash),
-      newStamp(valuesObj, valuesHlc, valuesHash),
-      1,
-    ];
-  };
+  const getTransactionMergeableChanges = (withHashes = false) =>
+    getTransactionMergeableChangesImpl(withHashes);
+  const getEncodedTransactionMergeableChanges = (withHashes) =>
+    getTransactionMergeableChangesImpl(withHashes, true);
   const applyMergeableChanges = (mergeableChanges) =>
     disableListeningToRawStoreChanges(() =>
       store.applyChanges(mergeContentOrChanges(mergeableChanges)),
@@ -3279,10 +3385,13 @@ const createMergeableStore = (uniqueId, getNow) => {
     getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
-    // only used internally by other modules
-    hadMutated,
+    __: [
+      hadMutated,
+      getEncodedMergeableContent,
+      getEncodedTransactionMergeableChanges,
+    ],
   };
-  store.setInternalListeners(
+  store._[3](
     preStartTransaction,
     preFinishTransaction,
     postFinishTransaction,
@@ -3521,6 +3630,7 @@ const createMiddleware = getCreateFunction((store) => {
   const willDelValuesCallbacks = [];
   const willDelValueCallbacks = [];
   const willApplyChangesCallbacks = [];
+  const didSetRowCallbacksMap = mapNew();
   const willSetContent = (content) =>
     reduceCallbacks(willSetContentCallbacks, content);
   const willSetTables = (tables) =>
@@ -3547,6 +3657,17 @@ const createMiddleware = getCreateFunction((store) => {
     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);
@@ -3562,6 +3683,13 @@ const createMiddleware = getCreateFunction((store) => {
   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,
@@ -3579,9 +3707,10 @@ const createMiddleware = getCreateFunction((store) => {
     addWillDelValuesCallback,
     addWillDelValueCallback,
     addWillApplyChangesCallback,
+    addDidSetRowCallback,
     destroy,
   });
-  store.setMiddleware(
+  store._[4](
     willSetContent,
     willSetTables,
     willSetTable,
@@ -3596,20 +3725,20 @@ const createMiddleware = getCreateFunction((store) => {
     willDelValues,
     willDelValue,
     willApplyChanges,
+    didSetRow,
   );
   return middleware;
 });
 
 const createQueries = getCreateFunction((store) => {
-  const createStore = store.createStore;
+  const createStore = store._[0];
   const preStore = createStore();
   const resultStore = createStore();
   const preStoreListenerIds = mapNew();
   const paramValuesListeners = mapNew();
   const paramValueListeners = mapNew();
   const {
-    addListener,
-    callListeners,
+    _: [, addListener, callListeners],
     delListener: delListenerImpl,
   } = resultStore;
   const [
@@ -3928,7 +4057,7 @@ const createQueries = getCreateFunction((store) => {
       selectJoinWhereStore.transaction(() =>
         arrayEvery(wheres, (where2) => where2(getTableCell))
           ? mapForEach(selects, (asCellId, tableCellGetter) =>
-              selectJoinWhereStore.setOrDelCell(
+              selectJoinWhereStore._[5](
                 queryId,
                 rootRowId,
                 asCellId,