tinybase 5.0.0-beta.2 → 5.0.0-beta.4

package/lib/debug/tinybase.js

@@ -88,8 +88,8 @@ const isObject = (obj) =>
     /* istanbul ignore next */
     () => true,
   );
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objNew = (entries = []) => object.fromEntries(entries);
+const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
   delete obj[id];
   return obj;
@@ -1085,6 +1085,23 @@ const createMetrics = getCreateFunction((store) => {
 
 const scheduleRunning = mapNew();
 const scheduleActions = mapNew();
+const isMergeable = (contentOrChanges) => isString(contentOrChanges?.[0]);
+const getStoreFunctions = (supportsMergeableStore, store) =>
+  !supportsMergeableStore || isUndefined(store.getMergeableContent)
+    ? [
+        0,
+        store.getContent,
+        store.getTransactionChanges,
+        ([changedTables, changedValues]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+      ]
+    : [
+        1,
+        store.getMergeableContent,
+        store.getTransactionMergeableChanges,
+        ([, [[, changedTables], [, changedValues]]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+      ];
 const createCustomPersister = (
   store,
   getPersisted,
@@ -1092,6 +1109,7 @@ const createCustomPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
+  supportsMergeableStore,
   [getThing, thing] = [],
   scheduleId = [],
 ) => {
@@ -1104,6 +1122,8 @@ const createCustomPersister = (
   let listeningHandle;
   mapEnsure(scheduleRunning, scheduleId, () => 0);
   mapEnsure(scheduleActions, scheduleId, () => []);
+  const [isMergeableStore, getContent, getChanges, hasChanges] =
+    getStoreFunctions(supportsMergeableStore, store);
   const run = async () => {
     /* istanbul ignore else */
     if (!mapGet(scheduleRunning, scheduleId)) {
@@ -1139,7 +1159,10 @@ const createCustomPersister = (
     load: async (initialTables, initialValues) =>
       await loadLock(async () => {
         try {
-          store.setContent(await getPersisted());
+          const content = await getPersisted();
+          (isMergeableStore && isMergeable(content)
+            ? store.setMergeableContent
+            : store.setContent)(content);
         } catch {
           store.setContent([initialTables, initialValues]);
         }
@@ -1149,16 +1172,21 @@ const createCustomPersister = (
       await persister.load(initialTables, initialValues);
       listening = 1;
       listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
-          if (getTransactionChanges) {
-            const transactionChanges = getTransactionChanges();
+        async (getContent2, getChanges2) => {
+          if (getChanges2) {
+            const changes = getChanges2();
             await loadLock(async () =>
-              store.setTransactionChanges(transactionChanges),
+              (isMergeableStore && isMergeable(changes)
+                ? store.applyMergeableChanges
+                : store.applyChanges)(changes),
             );
           } else {
             await loadLock(async () => {
               try {
-                store.setContent(getContent?.() ?? (await getPersisted()));
+                const content = getContent2?.() ?? (await getPersisted());
+                (isMergeableStore && isMergeable(content)
+                  ? store.setMergeableContent
+                  : store.setContent)(content);
               } catch (error) {
                 onIgnoredError?.(error);
               }
@@ -1176,7 +1204,7 @@ const createCustomPersister = (
       }
       return persister;
     },
-    save: async (getTransactionChanges) => {
+    save: async (getChanges2) => {
       /* istanbul ignore else */
       if (loadSave != 1) {
         loadSave = 2;
@@ -1185,7 +1213,7 @@ const createCustomPersister = (
         }
         await persister.schedule(async () => {
           try {
-            await setPersisted(store.getContent, getTransactionChanges);
+            await setPersisted(getContent, getChanges2);
           } catch (error) {
             /* istanbul ignore next */
             onIgnoredError?.(error);
@@ -1197,14 +1225,12 @@ const createCustomPersister = (
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
-      listenerId = store.addDidFinishTransactionListener(
-        (_store, getTransactionChanges) => {
-          const [tableChanges, valueChanges] = getTransactionChanges();
-          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
-            persister.save(() => [tableChanges, valueChanges]);
-          }
-        },
-      );
+      listenerId = store.addDidFinishTransactionListener(() => {
+        const changes = getChanges();
+        if (hasChanges(changes)) {
+          persister.save(() => changes);
+        }
+      });
       return persister;
     },
     stopAutoSave: () => {
@@ -1875,51 +1901,36 @@ const createRelationships = getCreateFunction((store) => {
   return objFreeze(relationships);
 });
 
-const newStamped = () => [EMPTY_STRING, null];
-const newStampedMap = () => [EMPTY_STRING, mapNew()];
-const mapStampedMapToObj = (stampedMap, mapper) =>
-  mapStamped(stampedMap, (map, stamp) => [
-    stamp,
-    isUndefined(map) ? null : mapToObj(map, mapper),
-  ]);
-const mapStamped = ([stamp, value], mapper) => mapper(value, stamp);
-const mergeStamp = (
-  [newStamp, newThing],
-  currentStampedThing,
-  getNextCurrentThing,
-  ifNewer = 0,
-) => {
-  const isNewer = newStamp > currentStampedThing[0];
-  if ((!ifNewer && currentStampedThing[1] !== null) || isNewer) {
-    currentStampedThing[1] = getNextCurrentThing(
-      newThing,
-      currentStampedThing[1],
-    );
-  }
-  if (isNewer) {
-    currentStampedThing[0] = newStamp;
-  }
-  return currentStampedThing;
-};
-const mergeEachStamp = (thingStamps, allThingStamps, changes, forEachThing) => {
-  objForEach(thingStamps, (thingStamp, thingId) =>
+const stampNew = (time = EMPTY_STRING, thing) => [time, thing];
+const stampNewMap = (time = EMPTY_STRING) => stampNew(time, mapNew());
+const stampNewObj = (time) => stampNew(time, objNew());
+const mapStamp = ([time, value], mapper) => [time, mapper(value, time)];
+const cloneStamp = ([time, value]) => [time, value];
+const mapStampMapToObj = (stampedMap, mapper) =>
+  mapStamp(stampedMap, (map) => mapToObj(map, mapper));
+const mergeStamps = (newThingStamps, thingStamps, changes, merge) =>
+  objForEach(newThingStamps, (newThingStamp, thingId) =>
     mergeStamp(
-      thingStamp,
-      mapEnsure(allThingStamps, thingId, newStamped),
-      (newThing, currentThing) => {
-        if (!forEachThing || isUndefined(newThing)) {
-          return (changes[thingId] = newThing ?? null);
-        }
-        currentThing ??= mapNew();
-        changes[thingId] = {};
-        forEachThing(newThing, currentThing, thingId);
-        return currentThing;
-      },
-      forEachThing ? 0 : 1,
+      newThingStamp,
+      mapEnsure(thingStamps, thingId, stampNewMap),
+      (changes[thingId] = objNew()),
+      merge,
     ),
   );
-  return allThingStamps;
+const mergeStamp = ([newTime, newThing], thingStamp, changes, merge) => {
+  if (newTime > thingStamp[0]) {
+    thingStamp[0] = newTime;
+  }
+  merge(newThing, thingStamp[1], changes);
 };
+const mergeLeafStamps = (newLeafStamps, leafStamps, changes) =>
+  objForEach(newLeafStamps, ([newTime, newLeaf], leafId) => {
+    const leafStamp = mapEnsure(leafStamps, leafId, stampNew);
+    if (newTime > leafStamp[0]) {
+      leafStamp[0] = newTime;
+      leafStamp[1] = changes[leafId] = newLeaf;
+    }
+  });
 
 const pairNew = (value) => [value, value];
 const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
@@ -1954,12 +1965,10 @@ const idsChanged = (changedIds, id2, addedOrRemoved) =>
 const createStore = () => {
   let hasTablesSchema;
   let hasValuesSchema;
-  let cellsTouched = false;
-  let valuesTouched = false;
   let hadTables = false;
   let hadValues = false;
   let transactions = 0;
-  let postTransactionListener;
+  let internalListeners = [];
   const changedTableIds = mapNew();
   const changedTableCellIds = mapNew();
   const changedRowCount = mapNew();
@@ -2601,44 +2610,6 @@ const createStore = () => {
     transaction(() => actions(...arrayMap(args, id)));
     return store;
   };
-  const getTransactionChanges = () => [
-    mapToObj(
-      changedCells,
-      (table, tableId) =>
-        mapGet(changedTableIds, tableId) === -1
-          ? null
-          : mapToObj(
-              table,
-              (row, rowId) =>
-                mapGet(mapGet(changedRowIds, tableId), rowId) === -1
-                  ? null
-                  : mapToObj(
-                      row,
-                      ([, newCell]) => newCell ?? null,
-                      (_, changedCell) => pairIsEqual(changedCell),
-                    ),
-              objIsEmpty,
-            ),
-      objIsEmpty,
-    ),
-    mapToObj(
-      changedValues,
-      ([, newValue]) => newValue ?? null,
-      (_, changedValue) => pairIsEqual(changedValue),
-    ),
-  ];
-  const getTransactionLog = () => ({
-    cellsTouched,
-    valuesTouched,
-    changedCells: mapToObj3(changedCells, pairClone, pairIsEqual),
-    invalidCells: mapToObj3(invalidCells),
-    changedValues: mapToObj(changedValues, pairClone, pairIsEqual),
-    invalidValues: mapToObj(invalidValues),
-    changedTableIds: mapToObj(changedTableIds),
-    changedRowIds: mapToObj2(changedRowIds),
-    changedCellIds: mapToObj3(changedCellIds),
-    changedValueIds: mapToObj(changedValueIds),
-  });
   const getContent = () => [getTables(), getValues()];
   const getTables = () => mapToObj3(tablesMap);
   const getTableIds = () => mapKeys(tablesMap);
@@ -2786,9 +2757,9 @@ const createStore = () => {
         ),
       valueId,
     );
-  const setTransactionChanges = (transactionChanges) =>
+  const applyChanges = (changes) =>
     fluentTransaction(() => {
-      objToArray(transactionChanges[0], (table, tableId) =>
+      objToArray(changes[0], (table, tableId) =>
         isUndefined(table)
           ? delTable(tableId)
           : objToArray(table, (row, rowId) =>
@@ -2799,7 +2770,7 @@ const createStore = () => {
                   ),
             ),
       );
-      objToArray(transactionChanges[1], (value, valueId) =>
+      objToArray(changes[1], (value, valueId) =>
         setOrDelValue(store, valueId, value),
       );
     });
@@ -2926,31 +2897,62 @@ const createStore = () => {
       transactions++;
     }
     if (transactions == 1) {
-      callListeners(
-        startTransactionListeners,
-        void 0,
-        getTransactionChanges,
-        getTransactionLog,
-      );
+      callListeners(startTransactionListeners, void 0);
     }
     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),
+                    ),
+              objIsEmpty,
+            ),
+      objIsEmpty,
+    ),
+    mapToObj(
+      changedValues,
+      ([, newValue]) => newValue,
+      (_, changedValue) => pairIsEqual(changedValue),
+    ),
+  ];
+  const getTransactionLog = () => [
+    !collIsEmpty(changedCells),
+    !collIsEmpty(changedValues),
+    mapToObj3(changedCells, pairClone, pairIsEqual),
+    mapToObj3(invalidCells),
+    mapToObj(changedValues, pairClone, pairIsEqual),
+    mapToObj(invalidValues),
+    mapToObj(changedTableIds),
+    mapToObj2(changedRowIds),
+    mapToObj3(changedCellIds),
+    mapToObj(changedValueIds),
+  ];
   const finishTransaction = (doRollback) => {
     if (transactions > 0) {
       transactions--;
       if (transactions == 0) {
-        cellsTouched = !collIsEmpty(changedCells);
-        valuesTouched = !collIsEmpty(changedValues);
         transactions = 1;
         callInvalidCellListeners(1);
-        if (cellsTouched) {
+        if (!collIsEmpty(changedCells)) {
           callTabularListenersForChanges(1);
         }
         callInvalidValueListeners(1);
-        if (valuesTouched) {
+        if (!collIsEmpty(changedValues)) {
           callValuesListenersForChanges(1);
         }
-        if (doRollback?.(getTransactionChanges, getTransactionLog)) {
+        if (doRollback?.(store)) {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
@@ -2958,39 +2960,26 @@ const createStore = () => {
               ),
             ),
           );
+          collClear(changedCells);
           collForEach(changedValues, ([oldValue], valueId) =>
             setOrDelValue(store, valueId, oldValue),
           );
-          cellsTouched = valuesTouched = false;
+          collClear(changedValues);
         }
-        callListeners(
-          finishTransactionListeners[0],
-          void 0,
-          getTransactionChanges,
-          getTransactionLog,
-        );
+        callListeners(finishTransactionListeners[0], void 0);
         transactions = -1;
         callInvalidCellListeners(0);
-        if (cellsTouched) {
+        if (!collIsEmpty(changedCells)) {
           callTabularListenersForChanges(0);
         }
         callInvalidValueListeners(0);
-        if (valuesTouched) {
+        if (!collIsEmpty(changedValues)) {
           callValuesListenersForChanges(0);
         }
-        callListeners(
-          finishTransactionListeners[1],
-          void 0,
-          getTransactionChanges,
-          getTransactionLog,
-        );
-        postTransactionListener?.(
-          store,
-          getTransactionChanges,
-          getTransactionLog,
-        );
+        internalListeners[0]?.(store);
+        callListeners(finishTransactionListeners[1], void 0);
+        internalListeners[1]?.(store);
         transactions = 0;
-        cellsTouched = valuesTouched = false;
         hadTables = hasTables();
         hadValues = hasValues();
         arrayForEach(
@@ -3115,9 +3104,8 @@ const createStore = () => {
       collSize2(startTransactionListeners) +
       pairCollSize2(finishTransactionListeners),
   });
-  const addPostTransactionListener = (listener) => {
-    postTransactionListener = listener;
-  };
+  const setInternalListeners = (preFinishTransaction, postFinishTransaction) =>
+    (internalListeners = [preFinishTransaction, postFinishTransaction]);
   const store = {
     getContent,
     getTables,
@@ -3158,7 +3146,7 @@ const createStore = () => {
     setValues,
     setPartialValues,
     setValue,
-    setTransactionChanges,
+    applyChanges,
     setTablesJson,
     setValuesJson,
     setJson,
@@ -3176,6 +3164,8 @@ const createStore = () => {
     delSchema,
     transaction,
     startTransaction,
+    getTransactionChanges,
+    getTransactionLog,
     finishTransaction,
     forEachTable,
     forEachTableCell,
@@ -3193,7 +3183,7 @@ const createStore = () => {
     createStore,
     addListener,
     callListeners,
-    addPostTransactionListener,
+    setInternalListeners,
   };
   objToArray(
     {
@@ -3320,23 +3310,23 @@ const decodeHlc = (hlc16) => [
 ];
 const getHlcFunctions = (uniqueId) => {
   let logicalTime = 0;
-  let counter = 0;
+  let lastCounter = -1;
   const uniqueIdHash = hash(uniqueId);
   const getHlc = () => {
     seenHlc();
-    return encodeHlc(logicalTime, ++counter, uniqueIdHash);
+    return encodeHlc(logicalTime, ++lastCounter, uniqueIdHash);
   };
   const seenHlc = (hlc) => {
     const previousLogicalTime = logicalTime;
     const [remoteLogicalTime, remoteCounter] = isUndefined(hlc)
       ? [0, 0]
       : decodeHlc(hlc);
-    logicalTime = Math.max(previousLogicalTime, remoteLogicalTime, Date.now());
-    counter =
+    logicalTime = mathMax(previousLogicalTime, remoteLogicalTime, Date.now());
+    lastCounter =
       logicalTime == previousLogicalTime
         ? logicalTime == remoteLogicalTime
-          ? Math.max(counter, remoteCounter)
-          : counter
+          ? mathMax(lastCounter, remoteCounter)
+          : lastCounter
         : logicalTime == remoteLogicalTime
           ? remoteCounter
           : -1;
@@ -3362,119 +3352,166 @@ const LISTENER_ARGS = {
   InvalidCell: 3,
   InvalidValue: 1,
 };
+const newContentStamp = (time = EMPTY_STRING) => [
+  time,
+  [stampNewMap(time), stampNewMap(time)],
+];
 const createMergeableStore = (id) => {
   let listening = 1;
+  let contentStamp = newContentStamp();
+  let transactionTime;
+  let finishTransactionMergeableChanges;
   const [getHlc, seenHlc] = getHlcFunctions(id);
   const store = createStore();
-  const allContentStamp = [EMPTY_STRING, [newStampedMap(), newStampedMap()]];
-  const postTransactionListener = (_, getTransactionChanges) => {
+  const disableListening = (actions) => {
+    const wasListening = listening;
+    listening = 0;
+    actions();
+    listening = wasListening;
+  };
+  const preFinishTransaction = () => {
     if (listening) {
-      const stamp = getHlc();
-      const [tablesChanges, valuesChanges] = getTransactionChanges();
-      const [allTablesStamp, allValuesStamp] = allContentStamp[1];
-      allContentStamp[0] = stamp;
-      if (!objIsEmpty(tablesChanges)) {
-        allTablesStamp[0] = stamp;
-        objToArray(tablesChanges, (tableChanges, tableId) => {
-          const allTableStamp = mapEnsure(
-            allTablesStamp[1],
-            tableId,
-            newStamped,
-          );
-          allTableStamp[0] = stamp;
-          if (isUndefined(tableChanges)) {
-            allTableStamp[1] = null;
-          } else {
-            const allRowsStamp = (allTableStamp[1] ??= mapNew());
-            objToArray(tableChanges, (rowChanges, rowId) => {
-              const allRowStamp = mapEnsure(allRowsStamp, rowId, newStamped);
-              allRowStamp[0] = stamp;
-              if (isUndefined(rowChanges)) {
-                allRowStamp[1] = null;
-              } else {
-                const allCellStamps = (allRowStamp[1] ??= mapNew());
-                objToArray(rowChanges, (cellChanges, cellId) =>
-                  mapSet(allCellStamps, cellId, [stamp, cellChanges]),
-                );
-              }
-            });
-          }
-        });
+      finishTransactionMergeableChanges = getTransactionMergeableChanges();
+      const [time, [changedTablesStamp, changedValuesStamp]] =
+        finishTransactionMergeableChanges;
+      const cellsTouched = !objIsEmpty(changedTablesStamp[1]);
+      const valuesTouched = !objIsEmpty(changedValuesStamp[1]);
+      const [, [tablesStamp, valuesStamp]] = contentStamp;
+      if (cellsTouched || valuesTouched) {
+        contentStamp[0] = time;
       }
-      if (!objIsEmpty(valuesChanges)) {
-        allValuesStamp[0] = stamp;
-        objToArray(valuesChanges, (valueChanges, valueId) => {
-          mapSet(allValuesStamp[1], valueId, [stamp, valueChanges]);
+      if (cellsTouched) {
+        tablesStamp[0] = time;
+        objToArray(changedTablesStamp[1], ([, changedRowStamps], tableId) => {
+          const tableStamp = mapEnsure(tablesStamp[1], tableId, stampNewMap);
+          tableStamp[0] = time;
+          objToArray(changedRowStamps, ([, changedCellStamps], rowId) => {
+            const rowStamp = mapEnsure(tableStamp[1], rowId, stampNewMap);
+            rowStamp[0] = time;
+            objToArray(changedCellStamps, ([, newCell], cellId) =>
+              mapSet(rowStamp[1], cellId, stampNew(time, newCell)),
+            );
+          });
         });
       }
+      if (valuesTouched) {
+        valuesStamp[0] = time;
+        objToArray(changedValuesStamp[1], ([, newValue], valueId) =>
+          mapSet(valuesStamp[1], valueId, stampNew(time, newValue)),
+        );
+      }
     }
   };
+  const postFinishTransaction = () =>
+    (transactionTime = finishTransactionMergeableChanges = void 0);
   const merge = (mergeableStore2) => {
     const mergeableContent = mergeableStore.getMergeableContent();
     const mergeableContent2 = mergeableStore2.getMergeableContent();
-    mergeableStore2.applyMergeableContent(mergeableContent);
-    return applyMergeableContent(mergeableContent2);
+    mergeableStore2.applyMergeableChanges(mergeableContent);
+    return applyMergeableChanges(mergeableContent2);
   };
   const getMergeableContent = () =>
-    mapStamped(allContentStamp, ([allTablesStamp, allValuesStamp], stamp) => [
-      stamp,
-      [
-        mapStampedMapToObj(allTablesStamp, (allRowStamp) =>
-          mapStampedMapToObj(allRowStamp, (allCellsStamp) =>
-            mapStampedMapToObj(allCellsStamp, pairClone),
-          ),
+    mapStamp(contentStamp, ([tablesStamp, valuesStamp]) => [
+      mapStampMapToObj(tablesStamp, (rowsStamp) =>
+        mapStampMapToObj(rowsStamp, (cellsStamp) =>
+          mapStampMapToObj(cellsStamp, cloneStamp),
         ),
-        mapStampedMapToObj(allValuesStamp, pairClone),
-      ],
+      ),
+      mapStampMapToObj(valuesStamp, cloneStamp),
     ]);
-  const applyMergeableContent = (mergeableContent) => {
+  const setMergeableContent = (mergeableContent) => {
+    disableListening(() =>
+      store.transaction(() => {
+        store.delTables().delValues();
+        contentStamp = newContentStamp();
+      }),
+    );
+    applyMergeableChanges(mergeableContent);
+    return mergeableStore;
+  };
+  const getTransactionMergeableChanges = () => {
+    if (isUndefined(finishTransactionMergeableChanges)) {
+      const [, , changedCells, , changedValues] = store.getTransactionLog();
+      const time =
+        !objIsEmpty(changedCells) || !objIsEmpty(changedValues)
+          ? transactionTime ?? (transactionTime = getHlc())
+          : EMPTY_STRING;
+      const mergeableChanges = stampNew(time, [
+        stampNewObj(objIsEmpty(changedCells) ? EMPTY_STRING : time),
+        stampNewObj(objIsEmpty(changedValues) ? EMPTY_STRING : time),
+      ]);
+      const [[, tableStamps], [, valuesStamp]] = mergeableChanges[1];
+      objToArray(changedCells, (changedTable, tableId) => {
+        const [, rowStamps] = (tableStamps[tableId] = stampNewObj(time));
+        objToArray(changedTable, (changedRow, rowId) => {
+          const [, cellStamps] = (rowStamps[rowId] = stampNewObj(time));
+          objToArray(
+            changedRow,
+            ([, newCell], cellId) =>
+              (cellStamps[cellId] = stampNew(time, newCell)),
+          );
+        });
+      });
+      objToArray(
+        changedValues,
+        ([, newValue], valueId) =>
+          (valuesStamp[valueId] = stampNew(time, newValue)),
+      );
+      return mergeableChanges;
+    }
+    return finishTransactionMergeableChanges;
+  };
+  const applyMergeableChanges = (newContentStamp2) => {
     const changes = [{}, {}];
-    seenHlc(mergeableContent[0]);
+    seenHlc(newContentStamp2[0]);
     mergeStamp(
-      mergeableContent,
-      allContentStamp,
-      ([tablesStamp, valuesStamp], [allTablesStamp, allValuesStamp]) => [
-        mergeStamp(tablesStamp, allTablesStamp, (tableStamps, allTableStamps) =>
-          mergeEachStamp(
-            tableStamps,
-            allTableStamps,
-            changes[0],
-            (rowStamps, allRowStamps, tableId) =>
-              mergeEachStamp(
-                rowStamps,
-                allRowStamps,
-                changes[0][tableId],
-                (cellStamps, allCellStamps, rowId) =>
-                  mergeEachStamp(
-                    cellStamps,
-                    allCellStamps,
-                    changes[0][tableId][rowId],
-                  ),
-              ),
-          ),
-        ),
-        mergeStamp(valuesStamp, allValuesStamp, (valueStamps, allValueStamps) =>
-          mergeEachStamp(valueStamps, allValueStamps, changes[1]),
-        ),
-      ],
+      newContentStamp2,
+      contentStamp,
+      changes,
+      (
+        [newTablesStamp, newValuesStamp],
+        [tablesStamp, valuesStamp],
+        [tablesChanges, valuesChanges],
+      ) => {
+        mergeStamp(
+          newTablesStamp,
+          tablesStamp,
+          tablesChanges,
+          (newTableStamps, tableStamps, tableChanges) =>
+            mergeStamps(
+              newTableStamps,
+              tableStamps,
+              tableChanges,
+              (newRowStamps, rowStamps, rowChanges) =>
+                mergeStamps(
+                  newRowStamps,
+                  rowStamps,
+                  rowChanges,
+                  mergeLeafStamps,
+                ),
+            ),
+        );
+        mergeStamp(newValuesStamp, valuesStamp, valuesChanges, mergeLeafStamps);
+      },
     );
-    listening = 0;
-    store.setTransactionChanges(changes);
-    listening = 1;
+    disableListening(() => store.applyChanges(changes));
     return mergeableStore;
   };
   const mergeableStore = {
     getMergeableContent,
-    applyMergeableContent,
+    setMergeableContent,
+    getTransactionMergeableChanges,
+    applyMergeableChanges,
     merge,
   };
-  store.addPostTransactionListener(postTransactionListener);
+  store.setInternalListeners(preFinishTransaction, postFinishTransaction);
   objToArray(
     store,
     (method, name) =>
       (mergeableStore[name] = // fluent methods
         strStartsWith(name, 'set') ||
         strStartsWith(name, 'del') ||
+        strStartsWith(name, 'apply') ||
         strEndsWith(name, 'Transaction') ||
         name == 'callListener'
           ? (...args) => {