tinybase 8.0.0-beta.1 → 8.0.0-beta.2

package/@types/middleware/index.d.ts

@@ -28,17 +28,17 @@ import type {
  * The WillSetContentCallback type describes a function that is called before
  * Content is set in the Store.
  *
- * The callback receives the Content (a [Tables, Values] tuple) that is about
- * to be set. It can return the Content (possibly transformed) to allow the
- * write, or `undefined` to prevent the Content from being set.
+ * The callback receives the Content (a [Tables, Values] tuple) that is about to
+ * be set. It can return the Content (possibly transformed) to allow the write,
+ * or `undefined` to prevent the Content from being set.
  *
  * Multiple WillSetContentCallback functions can be registered and they will be
  * called sequentially, the Content being updated successively. If any callback
  * returns `undefined`, the chain short-circuits and the Content will not be
  * set.
  * @param content The Content about to be set.
- * @returns The Content to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Content to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -54,8 +54,7 @@ export type WillSetContentCallback = (content: Content) => Content | undefined;
  *
  * Multiple WillSetTablesCallback functions can be registered and they will be
  * called sequentially, the Tables being updated successively. If any callback
- * returns `undefined`, the chain short-circuits and the Tables will not be
- * set.
+ * returns `undefined`, the chain short-circuits and the Tables will not be set.
  * @param tables The Tables object about to be set.
  * @returns The Tables to use (possibly transformed), or `undefined` to prevent
  * the write.
@@ -216,11 +215,11 @@ export type WillDelTablesCallback = () => boolean;
 export type WillDelTableCallback = (tableId: Id) => boolean;
 
 /**
- * The WillDelRowCallback type describes a function that is called before a
- * Row is deleted from the Store.
+ * The WillDelRowCallback type describes a function that is called before a Row
+ * is deleted from the Store.
  *
- * The callback receives the table Id and row Id of the Row about to be
- * deleted. It returns `true` to allow the deletion, or `false` to prevent it.
+ * The callback receives the table Id and row Id of the Row about to be deleted.
+ * It returns `true` to allow the deletion, or `false` to prevent it.
  *
  * Multiple WillDelRowCallback functions can be registered and they will be
  * called sequentially. If any callback returns `false`, the chain
@@ -303,8 +302,8 @@ export type WillDelValueCallback = (valueId: Id) => boolean;
  * callback returns `undefined`, the chain short-circuits and the Changes will
  * not be applied.
  * @param changes The Changes about to be applied.
- * @returns The Changes to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Changes to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -312,6 +311,49 @@ export type WillApplyChangesCallback = (
   changes: Changes,
 ) => Changes | undefined;
 
+/**
+ * The DidSetRowCallback type describes a function called after a Row is changed
+ * during a transaction, and after mutator listeners have fired.
+ *
+ * Unlike the `willSet*` callbacks, which intercept writes as they happen,
+ * `didSetRow` fires once per touched Row after all cell writes in the
+ * transaction have completed. This means multiple cell changes to the same Row
+ * within a single transaction result in just one `didSetRow` call, with the
+ * full before-transaction and after-transaction Row states.
+ *
+ * The callback receives the Table Id, Row Id, the Row as it was at the start of
+ * the transaction (`oldRow`), and the Row as it is now (`newRow`). It must
+ * return a Row:
+ *
+ * - `newRow` to accept the changes.
+ * - a different `Row` to replace the final state.
+ * - `oldRow` to revert all changes to the Row.
+ * - an empty object to delete the Row.
+ *
+ * Multiple DidSetRowCallback functions can be registered for the same table and
+ * they will be called sequentially, each receiving the Row returned by the
+ * previous callback. The chain never short-circuits: all registered callbacks
+ * always run.
+ *
+ * Note that `addDidSetRowCallback` is table-scoped: you must specify the table
+ * Id when registering. Callbacks are only invoked for rows in the specified
+ * table, keeping overhead to zero for other tables.
+ * @param tableId The Id of the Table containing the changed Row.
+ * @param rowId The Id of the Row that was changed.
+ * @param oldRow The Row as it was at the start of the transaction.
+ * @param newRow The Row as it is now, after all cell writes including those
+ * made by mutating listeners.
+ * @returns The Row to use as the final state.
+ * @category Callback
+ * @since v8.0.0
+ */
+export type DidSetRowCallback = (
+  tableId: Id,
+  rowId: Id,
+  oldRow: Row,
+  newRow: Row,
+) => Row;
+
 /**
  * A Middleware object lets you intercept and validate writes to a Store.
  *
@@ -360,14 +402,13 @@ export interface Middleware {
   getStore(): Store;
 
   /**
-   * The addWillSetContentCallback method registers a
-   * WillSetContentCallback that will be called before Content is set in the
-   * Store.
+   * The addWillSetContentCallback method registers a WillSetContentCallback
+   * that will be called before Content is set in the Store.
    *
-   * The callback can transform the Content or return `undefined` to prevent
-   * the write. Multiple callbacks can be registered and they are called
-   * sequentially, each receiving the (possibly transformed) Content from
-   * the previous callback.
+   * The callback can transform the Content or return `undefined` to prevent the
+   * write. Multiple callbacks can be registered and they are called
+   * sequentially, each receiving the (possibly transformed) Content from the
+   * previous callback.
    * @param callback The WillSetContentCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -756,9 +797,9 @@ export interface Middleware {
    * The addWillDelTablesCallback method registers a WillDelTablesCallback that
    * will be called before all Tables are deleted from the Store.
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTablesCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -790,9 +831,9 @@ export interface Middleware {
    * The addWillDelTableCallback method registers a WillDelTableCallback that
    * will be called before any Table is deleted from the Store.
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTableCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -957,9 +998,9 @@ export interface Middleware {
   addWillDelValueCallback(callback: WillDelValueCallback): Middleware;
 
   /**
-   * The addWillApplyChangesCallback method registers a
-   * WillApplyChangesCallback that will be called before Changes are applied to
-   * the Store via the applyChanges method.
+   * The addWillApplyChangesCallback method registers a WillApplyChangesCallback
+   * that will be called before Changes are applied to the Store via the
+   * applyChanges method.
    *
    * This callback receives the Changes object and can return it (to allow),
    * return a modified Changes object (to transform), or return `undefined` (to
@@ -1003,6 +1044,82 @@ export interface Middleware {
    */
   addWillApplyChangesCallback(callback: WillApplyChangesCallback): Middleware;
 
+  /**
+   * The addDidSetRowCallback method registers a DidSetRowCallback for a
+   * specific table that will be called after any Row in that table is changed
+   * during a transaction, after mutator listeners have fired.
+   *
+   * Unlike `willSetRow`, which fires synchronously during each write, this
+   * callback fires once per changed Row after all cell writes in the
+   * transaction have landed. Multiple cell changes to the same Row within a
+   * transaction produce a single callback with the full before/after Row
+   * states.
+   *
+   * The callback receives `oldRow` (the Row at the start of the transaction)
+   * and `newRow` (the Row after all writes). Return `newRow` to accept, a
+   * different `Row` to replace, `oldRow` to revert, or an empty object to
+   * delete.
+   * @param tableId The Id of the Table to watch.
+   * @param callback The DidSetRowCallback to register.
+   * @returns A reference to the Middleware object, for chaining.
+   * @example
+   * This example registers a callback that validates the 'pets' table,
+   * reverting any row that ends up without a required 'species' cell.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * middleware.addDidSetRowCallback('pets', (_tableId, _rowId, oldRow, newRow) =>
+   *   'species' in newRow ? newRow : oldRow,
+   * );
+   *
+   * store.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
+   * console.log(store.getRow('pets', 'fido'));
+   * // -> {species: 'dog', name: 'Fido'}
+   *
+   * store.setRow('pets', 'nemo', {name: 'Nemo'});
+   * console.log(store.getRow('pets', 'nemo'));
+   * // -> {}
+   *
+   * middleware.destroy();
+   * ```
+   * @example
+   * This example shows that multiple cell changes in one transaction result in
+   * a single didSetRow callback with the full before/after row states.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * const seen = [];
+   * middleware.addDidSetRowCallback('pets', (_tableId, rowId, oldRow, newRow) => {
+   *   seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
+   *   return newRow;
+   * });
+   *
+   * store.transaction(() => {
+   *   store.setCell('pets', 'fido', 'name', 'Fido');
+   *   store.setCell('pets', 'fido', 'species', 'dog');
+   * });
+   * console.log(seen.length);
+   * // -> 1
+   * console.log(seen[0].rowId);
+   * // -> 'fido'
+   * console.log(seen[0].newRow);
+   * // -> {name: 'Fido', species: 'dog'}
+   *
+   * middleware.destroy();
+   * ```
+   * @category Configuration
+   * @since v8.0.0
+   */
+  addDidSetRowCallback(tableId: Id, callback: DidSetRowCallback): Middleware;
+
   /**
    * The destroy method should be called when this Middleware object is no
    * longer used. It removes all hooks and listeners from the Store, and

package/@types/middleware/with-schemas/index.d.ts

@@ -40,17 +40,17 @@ import type {
  * (content: Content) => Content | undefined;
  * ```
  *
- * The callback receives the Content (a [Tables, Values] tuple) that is about
- * to be set. It can return the Content (possibly transformed) to allow the
- * write, or `undefined` to prevent the Content from being set.
+ * The callback receives the Content (a [Tables, Values] tuple) that is about to
+ * be set. It can return the Content (possibly transformed) to allow the write,
+ * or `undefined` to prevent the Content from being set.
  *
  * Multiple WillSetContentCallback functions can be registered and they will be
  * called sequentially, the Content being updated successively. If any callback
  * returns `undefined`, the chain short-circuits and the Content will not be
  * set.
  * @param content The Content about to be set.
- * @returns The Content to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Content to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -74,8 +74,7 @@ export type WillSetContentCallback<Schemas extends OptionalSchemas> = (
  *
  * Multiple WillSetTablesCallback functions can be registered and they will be
  * called sequentially, the Tables being updated successively. If any callback
- * returns `undefined`, the chain short-circuits and the Tables will not be
- * set.
+ * returns `undefined`, the chain short-circuits and the Tables will not be set.
  * @param tables The Tables object about to be set.
  * @returns The Tables to use (possibly transformed), or `undefined` to prevent
  * the write.
@@ -328,8 +327,8 @@ export type WillDelTableCallback<
 > = (...params: Params | [tableId: never]) => boolean;
 
 /**
- * The WillDelRowCallback type describes a function that is called before a
- * Row is deleted from the Store.
+ * The WillDelRowCallback type describes a function that is called before a Row
+ * is deleted from the Store.
  *
  * This has schema-based typing. The following is a simplified representation:
  *
@@ -337,8 +336,8 @@ export type WillDelTableCallback<
  * (tableId: Id, rowId: Id) => boolean;
  * ```
  *
- * The callback receives the table Id and row Id of the Row about to be
- * deleted. It returns `true` to allow the deletion, or `false` to prevent it.
+ * The callback receives the table Id and row Id of the Row about to be deleted.
+ * It returns `true` to allow the deletion, or `false` to prevent it.
  *
  * Multiple WillDelRowCallback functions can be registered and they will be
  * called sequentially. If any callback returns `false`, the chain
@@ -468,8 +467,8 @@ export type WillDelValueCallback<
  * callback returns `undefined`, the chain short-circuits and the Changes will
  * not be applied.
  * @param changes The Changes about to be applied.
- * @returns The Changes to use (possibly transformed), or `undefined` to
- * prevent the write.
+ * @returns The Changes to use (possibly transformed), or `undefined` to prevent
+ * the write.
  * @category Callback
  * @since v8.0.0
  */
@@ -477,6 +476,63 @@ export type WillApplyChangesCallback<Schemas extends OptionalSchemas> = (
   changes: Changes<Schemas>,
 ) => Changes<Schemas> | undefined;
 
+/**
+ * The DidSetRowCallback type describes a function called after a Row is changed
+ * during a transaction, and after mutator listeners have fired.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * (
+ *   tableId: Id,
+ *   rowId: Id,
+ *   oldRow: Row,
+ *   newRow: Row,
+ * ) => Row;
+ * ```
+ *
+ * Unlike the `willSet*` callbacks, which intercept writes as they happen,
+ * `didSetRow` fires once per touched Row after all cell writes in the
+ * transaction have completed. This means multiple cell changes to the same Row
+ * within a single transaction result in just one `didSetRow` call, with the
+ * full before-transaction and after-transaction Row states.
+ *
+ * The callback receives the Table Id, Row Id, the Row as it was at the start of
+ * the transaction (`oldRow`), and the Row as it is now (`newRow`). It must
+ * return a Row:
+ *
+ * - `newRow` to accept the changes.
+ * - a different `Row` to replace the final state.
+ * - `oldRow` to revert all changes to the Row.
+ * - an empty object to delete the Row.
+ *
+ * Multiple DidSetRowCallback functions can be registered for the same table and
+ * they will be called sequentially, each receiving the Row returned by the
+ * previous callback. The chain never short-circuits: all registered callbacks
+ * always run.
+ *
+ * Note that `addDidSetRowCallback` is table-scoped: you must specify the table
+ * Id when registering. Callbacks are only invoked for rows in the specified
+ * table, keeping overhead to zero for other tables.
+ * @param tableId The Id of the Table containing the changed Row.
+ * @param rowId The Id of the Row that was changed.
+ * @param oldRow The Row as it was at the start of the transaction.
+ * @param newRow The Row as it is now, after all cell writes including those
+ * made by mutating listeners.
+ * @returns The Row to use as the final state.
+ * @category Callback
+ * @since v8.0.0
+ */
+export type DidSetRowCallback<
+  Schema extends OptionalTablesSchema,
+  TableId extends TableIdFromSchema<Schema>,
+> = (
+  tableId: TableId,
+  rowId: Id,
+  oldRow: Row<Schema, TableId>,
+  newRow: Row<Schema, TableId>,
+) => Row<Schema, TableId>;
+
 /**
  * A Middleware object lets you intercept and validate writes to a Store.
  *
@@ -531,9 +587,8 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
   getStore(): Store<Schemas>;
 
   /**
-   * The addWillSetContentCallback method registers a
-   * WillSetContentCallback that will be called before Content is set in the
-   * Store.
+   * The addWillSetContentCallback method registers a WillSetContentCallback
+   * that will be called before Content is set in the Store.
    *
    * This has schema-based typing. The following is a simplified representation:
    *
@@ -541,10 +596,10 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * addWillSetContentCallback(callback: WillSetContentCallback): Middleware;
    * ```
    *
-   * The callback can transform the Content or return `undefined` to prevent
-   * the write. Multiple callbacks can be registered and they are called
-   * sequentially, each receiving the (possibly transformed) Content from
-   * the previous callback.
+   * The callback can transform the Content or return `undefined` to prevent the
+   * write. Multiple callbacks can be registered and they are called
+   * sequentially, each receiving the (possibly transformed) Content from the
+   * previous callback.
    * @param callback The WillSetContentCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -989,9 +1044,9 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * addWillDelTablesCallback(callback: WillDelTablesCallback): Middleware;
    * ```
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTablesCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -1031,9 +1086,9 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * addWillDelTableCallback(callback: WillDelTableCallback): Middleware;
    * ```
    *
-   * The callback returns `true` to allow the deletion or `false` to prevent
-   * it. Multiple callbacks can be registered and they are called sequentially.
-   * If any callback returns `false`, the deletion is prevented.
+   * The callback returns `true` to allow the deletion or `false` to prevent it.
+   * Multiple callbacks can be registered and they are called sequentially. If
+   * any callback returns `false`, the deletion is prevented.
    * @param callback The WillDelTableCallback to register.
    * @returns A reference to the Middleware object, for chaining.
    * @example
@@ -1232,9 +1287,9 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
   ): Middleware<Schemas>;
 
   /**
-   * The addWillApplyChangesCallback method registers a
-   * WillApplyChangesCallback that will be called before Changes are applied to
-   * the Store via the applyChanges method.
+   * The addWillApplyChangesCallback method registers a WillApplyChangesCallback
+   * that will be called before Changes are applied to the Store via the
+   * applyChanges method.
    *
    * This has schema-based typing. The following is a simplified representation:
    *
@@ -1286,6 +1341,91 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
     callback: WillApplyChangesCallback<Schemas>,
   ): Middleware<Schemas>;
 
+  /**
+   * The addDidSetRowCallback method registers a DidSetRowCallback for a
+   * specific table that will be called after any Row in that table is changed
+   * during a transaction, after mutator listeners have fired.
+   *
+   * This has schema-based typing. The following is a simplified representation:
+   *
+   * ```ts override
+   * addDidSetRowCallback(tableId: Id, callback: DidSetRowCallback): Middleware;
+   * ```
+   *
+   * Unlike `willSetRow`, which fires synchronously during each write, this
+   * callback fires once per changed Row after all cell writes in the
+   * transaction have landed. Multiple cell changes to the same Row within a
+   * transaction produce a single callback with the full before/after Row
+   * states.
+   *
+   * The callback receives `oldRow` (the Row at the start of the transaction)
+   * and `newRow` (the Row after all writes). Return `newRow` to accept, a
+   * different `Row` to replace, `oldRow` to revert, or an empty object to
+   * delete.
+   * @param tableId The Id of the Table to watch.
+   * @param callback The DidSetRowCallback to register.
+   * @returns A reference to the Middleware object, for chaining.
+   * @example
+   * This example registers a callback that validates the 'pets' table,
+   * reverting any row that ends up without a required 'species' cell.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * middleware.addDidSetRowCallback('pets', (_tableId, _rowId, oldRow, newRow) =>
+   *   'species' in newRow ? newRow : oldRow,
+   * );
+   *
+   * store.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
+   * console.log(store.getRow('pets', 'fido'));
+   * // -> {species: 'dog', name: 'Fido'}
+   *
+   * store.setRow('pets', 'nemo', {name: 'Nemo'});
+   * console.log(store.getRow('pets', 'nemo'));
+   * // -> {}
+   *
+   * middleware.destroy();
+   * ```
+   * @example
+   * This example shows that multiple cell changes in one transaction result in
+   * a single didSetRow callback with the full before/after row states.
+   *
+   * ```js
+   * import {createMiddleware, createStore} from 'tinybase';
+   *
+   * const store = createStore();
+   * const middleware = createMiddleware(store);
+   *
+   * const seen = [];
+   * middleware.addDidSetRowCallback('pets', (_tableId, rowId, oldRow, newRow) => {
+   *   seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
+   *   return newRow;
+   * });
+   *
+   * store.transaction(() => {
+   *   store.setCell('pets', 'fido', 'name', 'Fido');
+   *   store.setCell('pets', 'fido', 'species', 'dog');
+   * });
+   * console.log(seen.length);
+   * // -> 1
+   * console.log(seen[0].rowId);
+   * // -> 'fido'
+   * console.log(seen[0].newRow);
+   * // -> {name: 'Fido', species: 'dog'}
+   *
+   * middleware.destroy();
+   * ```
+   * @category Configuration
+   * @since v8.0.0
+   */
+  addDidSetRowCallback<TableId extends TableIdFromSchema<Schemas[0]>>(
+    tableId: TableId,
+    callback: DidSetRowCallback<Schemas[0], TableId>,
+  ): Middleware<Schemas>;
+
   /**
    * The destroy method should be called when this Middleware object is no
    * longer used. It removes all hooks and listeners from the Store, and

package/index.js

@@ -131,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) => {
@@ -1863,6 +1864,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 +1899,7 @@ const createStore = () => {
             mapClone(changedRowCount),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
-            mapClone(changedCells, (map) =>
-              mapClone(map, (map2) => mapClone(map2, pairClone)),
-            ),
+            clonedChangedCells(changedCells),
           ]
         : [
             changedTableIds,
@@ -2461,6 +2464,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 +2504,7 @@ const createStore = () => {
           callInvalidCellListeners(1);
           if (!collIsEmpty(changedCells)) {
             callTabularListenersForChanges(1);
+            doDidSetRows();
           }
           callInvalidValueListeners(1);
           if (!collIsEmpty(changedValues)) {
@@ -2628,6 +2663,7 @@ const createStore = () => {
     willDelValues,
     willDelValue,
     willApplyChanges,
+    didSetRow,
   ) =>
     (middleware = [
       willSetContent,
@@ -2644,6 +2680,7 @@ const createStore = () => {
       willDelValues,
       willDelValue,
       willApplyChanges,
+      didSetRow,
     ]);
   const setInternalListeners = (
     preStartTransaction,
@@ -3521,6 +3558,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 +3585,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 +3611,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,6 +3635,7 @@ const createMiddleware = getCreateFunction((store) => {
     addWillDelValuesCallback,
     addWillDelValueCallback,
     addWillApplyChangesCallback,
+    addDidSetRowCallback,
     destroy,
   });
   store.setMiddleware(
@@ -3596,6 +3653,7 @@ const createMiddleware = getCreateFunction((store) => {
     willDelValues,
     willDelValue,
     willApplyChanges,
+    didSetRow,
   );
   return middleware;
 });