tinybase 5.0.0-beta.5 → 5.0.0-beta.6

package/lib/debug/mergeable-store.js

@@ -33,6 +33,7 @@ const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
   isUndefined(value) ? otherwise?.() : then(value);
 const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isString = (thing) => getTypeOf(thing) == STRING;
 const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
 const isArray = (thing) => Array.isArray(thing);
 const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
@@ -54,9 +55,7 @@ const arrayShift = (array) => array.shift();
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objEntries = object.entries;
-const objIds = object.keys;
 const objFrozen = object.isFrozen;
-const objFreeze = object.freeze;
 const isObject = (obj) =>
   !isUndefined(obj) &&
   ifNotUndefined(
@@ -67,6 +66,8 @@ const isObject = (obj) =>
     /* istanbul ignore next */
     () => true,
   );
+const objIds = object.keys;
+const objFreeze = object.freeze;
 const objNew = (entries = []) => object.fromEntries(entries);
 const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
@@ -77,6 +78,8 @@ const objForEach = (obj, cb) =>
   arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
 const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+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;
 const objEnsure = (obj, id, getDefaultValue) => {
@@ -85,6 +88,23 @@ const objEnsure = (obj, id, getDefaultValue) => {
   }
   return obj[id];
 };
+const objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
+  if (
+    isUndefined(obj) ||
+    !isObject(obj) ||
+    (!emptyIsValid && objIsEmpty(obj)) ||
+    objFrozen(obj)
+  ) {
+    onInvalidObj?.();
+    return false;
+  }
+  objToArray(obj, (child, id) => {
+    if (!validateChild(child, id)) {
+      objDel(obj, id);
+    }
+  });
+  return emptyIsValid ? true : !objIsEmpty(obj);
+};
 
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
@@ -121,24 +141,28 @@ const mapMatch = (map, obj, set, del = mapSet) => {
   mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
   return map;
 };
-const mapToObj = (map, mapValue, excludeValue) => {
+const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
   const obj = {};
-  collForEach(map, (value, id) => {
-    const mappedValue = mapValue ? mapValue(value, id) : value;
-    excludeValue?.(mappedValue, value) ? 0 : (obj[id] = mappedValue);
+  collForEach(map, (mapValue, id) => {
+    if (!excludeMapValue?.(mapValue, id)) {
+      const objValue = valueMapper ? valueMapper(mapValue, id) : mapValue;
+      excludeObjValue?.(objValue) ? 0 : (obj[id] = objValue);
+    }
   });
   return obj;
 };
-const mapToObj2 = (map, mapValue, excludeValue) =>
+const mapToObj2 = (map, valueMapper, excludeMapValue) =>
   mapToObj(
     map,
-    (childMap) => mapToObj(childMap, mapValue, excludeValue),
+    (childMap) => mapToObj(childMap, valueMapper, excludeMapValue),
+    collIsEmpty,
     objIsEmpty,
   );
-const mapToObj3 = (map, mapValue, excludeValue) =>
+const mapToObj3 = (map, valueMapper, excludeMapValue) =>
   mapToObj(
     map,
-    (childMap) => mapToObj2(childMap, mapValue, excludeValue),
+    (childMap) => mapToObj2(childMap, valueMapper, excludeMapValue),
+    collIsEmpty,
     objIsEmpty,
   );
 const mapClone = (map, mapValue) => {
@@ -181,25 +205,29 @@ const getHash = (value) => {
   return hash >>> 0;
 };
 
-const cloneHashStamp = ([time, value, hash]) => [time, value, hash];
-const stampNew = (time, thing) => [time, thing];
+const stampCloneWithHash = ([time, value, hash]) => [time, value, hash];
+const stampClone = ([time, value]) => [time, value];
+const getStampHash = (stamp) => stamp[2];
 const hashIdAndHash = (id, hash) => getHash(id + ':' + hash);
-const updateHashStamp = (hashStamp, hash, time) => {
-  hashStamp[2] = hash >>> 0;
-  if (time > hashStamp[0]) {
-    hashStamp[0] = time;
+const stampUpdate = (stamp, hash, time) => {
+  stamp[2] = hash >>> 0;
+  if (time > stamp[0]) {
+    stamp[0] = time;
   }
 };
-const stampNewObj = (time) => stampNew(time, objNew());
-const hashStampNewMap = (time = EMPTY_STRING) => [time, mapNew(), 0];
-const hashStampNewThing = () => [EMPTY_STRING, void 0, 0];
-const hashStampMap = ([time, value, hash], mapper) => [
-  time,
-  mapper(value, time),
-  hash,
-];
-const hashStampMapToObj = (hashStamp, mapper = cloneHashStamp) =>
-  hashStampMap(hashStamp, (map) => mapToObj(map, mapper));
+const stampNewObj = (time) => [time, objNew()];
+const stampNewMap = (time = EMPTY_STRING) => [time, mapNew(), 0];
+const stampMapToObjWithHash = (
+  [time, map, hash],
+  mapper = stampCloneWithHash,
+) => [time, mapToObj(map, mapper), hash];
+const stampValidate = (stamp, validateThing) =>
+  isArray(stamp) &&
+  size(stamp) == 3 &&
+  isString(stamp[0]) &&
+  validateThing(stamp[1]) &&
+  getTypeOf(stamp[2]) == NUMBER &&
+  isFiniteNumber(stamp[2]);
 
 const setNew = (entryOrEntries) =>
   new Set(
@@ -306,6 +334,8 @@ const getCellOrValueType = (cellOrValue) => {
     ? type
     : void 0;
 };
+const isCellOrValueOrNull = (cellOrValue) =>
+  cellOrValue === null || !isUndefined(getCellOrValueType(cellOrValue));
 const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
   isUndefined(cell)
     ? store.delCell(tableId, rowId, cellId, true)
@@ -322,18 +352,6 @@ const jsonParse = JSON.parse;
 const defaultSorter = (sortKey1, sortKey2) =>
   (sortKey1 ?? 0) < (sortKey2 ?? 0) ? -1 : 1;
 
-const validate = (obj, validateChild, onInvalidObj) => {
-  if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
-    onInvalidObj?.();
-    return false;
-  }
-  objToArray(obj, (child, id2) => {
-    if (!validateChild(child, id2)) {
-      objDel(obj, id2);
-    }
-  });
-  return !objIsEmpty(obj);
-};
 const idsChanged = (changedIds, id2, addedOrRemoved) =>
   mapSet(
     changedIds,
@@ -393,13 +411,13 @@ const createStore = () => {
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
   const validateTablesSchema = (tableSchema) =>
-    validate(tableSchema, (tableSchema2) =>
-      validate(tableSchema2, validateCellOrValueSchema),
+    objValidate(tableSchema, (tableSchema2) =>
+      objValidate(tableSchema2, validateCellOrValueSchema),
     );
   const validateValuesSchema = (valuesSchema) =>
-    validate(valuesSchema, validateCellOrValueSchema);
+    objValidate(valuesSchema, validateCellOrValueSchema);
   const validateCellOrValueSchema = (schema) => {
-    if (!validate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
+    if (!objValidate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
       return false;
     }
     const type = schema[TYPE];
@@ -412,18 +430,18 @@ const createStore = () => {
     return true;
   };
   const validateTables = (tables) =>
-    validate(tables, validateTable, cellInvalid);
+    objValidate(tables, validateTable, cellInvalid);
   const validateTable = (table, tableId) =>
     (!hasTablesSchema ||
       collHas(tablesSchemaMap, tableId) ||
       cellInvalid(tableId)) &&
-    validate(
+    objValidate(
       table,
       (row, rowId) => validateRow(tableId, rowId, row),
       () => cellInvalid(tableId),
     );
   const validateRow = (tableId, rowId, row, skipDefaults) =>
-    validate(
+    objValidate(
       skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
       (cell, cellId) =>
         ifNotUndefined(
@@ -450,7 +468,7 @@ const createStore = () => {
         ? cellInvalid(tableId, rowId, cellId, cell)
         : cell;
   const validateValues = (values, skipDefaults) =>
-    validate(
+    objValidate(
       skipDefaults ? values : addDefaultsToValues(values),
       (value, valueId) =>
         ifNotUndefined(
@@ -1293,17 +1311,20 @@ const createStore = () => {
                   : mapToObj(
                       row,
                       ([, newCell]) => newCell,
-                      (_, changedCell) => pairIsEqual(changedCell),
+                      (changedCell) => pairIsEqual(changedCell),
                     ),
+              collIsEmpty,
               objIsEmpty,
             ),
+      collIsEmpty,
       objIsEmpty,
     ),
     mapToObj(
       changedValues,
       ([, newValue]) => newValue,
-      (_, changedValue) => pairIsEqual(changedValue),
+      (changedValue) => pairIsEqual(changedValue),
     ),
+    1,
   ];
   const getTransactionLog = () => [
     !collIsEmpty(changedCells),
@@ -1690,10 +1711,13 @@ const getHlcFunctions = (uniqueId) => {
   };
   const seenHlc = (hlc) => {
     const previousLogicalTime = logicalTime;
-    const [remoteLogicalTime, remoteCounter] = isUndefined(hlc)
-      ? [0, 0]
-      : decodeHlc(hlc);
-    logicalTime = mathMax(previousLogicalTime, remoteLogicalTime, Date.now());
+    const [remoteLogicalTime, remoteCounter] =
+      isUndefined(hlc) || hlc == '' ? [0, 0] : decodeHlc(hlc);
+    logicalTime = mathMax(
+      previousLogicalTime,
+      remoteLogicalTime,
+      globalThis.HLC_TIME ?? Date.now(),
+    );
     lastCounter =
       logicalTime == previousLogicalTime
         ? logicalTime == remoteLogicalTime
@@ -1724,14 +1748,54 @@ const LISTENER_ARGS = {
   InvalidCell: 3,
   InvalidValue: 1,
 };
-const newContentHsm = (time = EMPTY_STRING) => [
+const newContentStampMap = (time = EMPTY_STRING) => [
   time,
-  [hashStampNewMap(time), hashStampNewMap(time)],
+  [stampNewMap(time), stampNewMap(time)],
   0,
 ];
+const validateMergeableContent = (mergeableContent) =>
+  stampValidate(
+    mergeableContent,
+    (content) =>
+      isArray(content) &&
+      size(content) == 2 &&
+      stampValidate(content[0], (tableStamps) =>
+        objValidate(
+          tableStamps,
+          (tableStamp) =>
+            stampValidate(tableStamp, (rowStamps) =>
+              objValidate(
+                rowStamps,
+                (rowStamp) =>
+                  stampValidate(rowStamp, (cellStamps) =>
+                    objValidate(
+                      cellStamps,
+                      (cellStamp) =>
+                        stampValidate(cellStamp, isCellOrValueOrNull),
+                      void 0,
+                      1,
+                    ),
+                  ),
+                void 0,
+                1,
+              ),
+            ),
+          void 0,
+          1,
+        ),
+      ) &&
+      stampValidate(content[1], (values) =>
+        objValidate(
+          values,
+          (value) => stampValidate(value, isCellOrValueOrNull),
+          void 0,
+          1,
+        ),
+      ),
+  );
 const createMergeableStore = (id) => {
   let listening = 1;
-  let contentHsm = newContentHsm();
+  let contentStampMap = newContentStampMap();
   let transactionTime;
   let transactionMergeableChanges;
   const [getHlc, seenHlc] = getHlcFunctions(id);
@@ -1741,6 +1805,7 @@ const createMergeableStore = (id) => {
     listening = 0;
     actions();
     listening = wasListening;
+    return mergeableStore;
   };
   const mergeContentOrChanges = (contentOrChanges, hasHashes = 0) => {
     const tablesChanges = {};
@@ -1750,8 +1815,8 @@ const createMergeableStore = (id) => {
       [[tablesTime, tablesObj, incomingTablesHash], values],
       incomingContentOrChangesHash,
     ] = contentOrChanges;
-    const [, [tablesHsm, valuesHsm]] = contentHsm;
-    const [oldTablesTime, tableHsms, oldTablesHash] = tablesHsm;
+    const [, [tablesStampMap, valuesStampMap]] = contentStampMap;
+    const [oldTablesTime, tableStampMaps, oldTablesHash] = tablesStampMap;
     if (tablesTime) {
       let tablesHash = hasHashes
         ? incomingTablesHash
@@ -1762,8 +1827,8 @@ const createMergeableStore = (id) => {
       objForEach(
         tablesObj,
         ([tableTime, rowsObj, incomingTableHash], tableId) => {
-          const tableHsm = mapEnsure(tableHsms, tableId, hashStampNewMap);
-          const [oldTableTime, rowHsms, oldTableHash] = tableHsm;
+          const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);
+          const [oldTableTime, rowStampMaps, oldTableHash] = tableStampMap;
           let tableHash = hasHashes
             ? incomingTableHash
             : oldTableHash ^
@@ -1774,7 +1839,7 @@ const createMergeableStore = (id) => {
           objForEach(rowsObj, (row, rowId) => {
             const [oldRowHash, rowHash] = mergeCellsOrValues(
               row,
-              mapEnsure(rowHsms, rowId, hashStampNewMap),
+              mapEnsure(rowStampMaps, rowId, stampNewMap),
               objEnsure(
                 objEnsure(tablesChanges, tableId, objNew),
                 rowId,
@@ -1787,26 +1852,33 @@ const createMergeableStore = (id) => {
               : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
                 hashIdAndHash(rowId, rowHash);
           });
-          updateHashStamp(tableHsm, tableHash, tableTime);
+          stampUpdate(tableStampMap, tableHash, tableTime);
           tablesHash ^= hasHashes
             ? 0
             : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
-              hashIdAndHash(tableId, tableHsm[2]);
+              hashIdAndHash(tableId, tableStampMap[2]);
         },
       );
-      updateHashStamp(tablesHsm, tablesHash, tablesTime);
+      stampUpdate(tablesStampMap, tablesHash, tablesTime);
     }
-    mergeCellsOrValues(values, valuesHsm, valuesChanges, hasHashes);
-    updateHashStamp(
-      contentHsm,
-      hasHashes ? incomingContentOrChangesHash : tablesHsm[2] ^ valuesHsm[2],
+    mergeCellsOrValues(values, valuesStampMap, valuesChanges, hasHashes);
+    stampUpdate(
+      contentStampMap,
+      hasHashes
+        ? incomingContentOrChangesHash
+        : tablesStampMap[2] ^ valuesStampMap[2],
       contentOrChangesTime,
     );
-    return [tablesChanges, valuesChanges];
+    return [tablesChanges, valuesChanges, 1];
   };
-  const mergeCellsOrValues = (things, thingsHsm, thingsChanges, hasHashes) => {
+  const mergeCellsOrValues = (
+    things,
+    thingsStampMap,
+    thingsChanges,
+    hasHashes,
+  ) => {
     const [thingsTime, thingsObj, incomingThingsHash] = things;
-    const [oldThingsTime, thingHsms, oldThingsHash] = thingsHsm;
+    const [oldThingsTime, thingStampMaps, oldThingsHash] = thingsStampMap;
     if (thingsTime) {
       let thingsHash = hasHashes
         ? incomingThingsHash
@@ -1817,28 +1889,32 @@ const createMergeableStore = (id) => {
       objForEach(
         thingsObj,
         ([thingTime, thing, incomingThingHash], thingId) => {
-          const thingHsm = mapEnsure(thingHsms, thingId, hashStampNewThing);
-          const [oldThingTime, , oldThingHash] = thingHsm;
+          const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [
+            EMPTY_STRING,
+            void 0,
+            0,
+          ]);
+          const [oldThingTime, , oldThingHash] = thingStampMap;
           if (thingTime > oldThingTime) {
-            updateHashStamp(
-              thingHsm,
+            stampUpdate(
+              thingStampMap,
               hasHashes
                 ? incomingThingHash
                 : getHash(jsonString(thing ?? null) + ':' + thingTime),
               thingTime,
             );
-            thingHsm[1] = thing;
+            thingStampMap[1] = thing;
             thingsChanges[thingId] = thing;
             thingsHash ^= hasHashes
               ? 0
               : hashIdAndHash(thingId, oldThingHash) ^
-                hashIdAndHash(thingId, thingHsm[2]);
+                hashIdAndHash(thingId, thingStampMap[2]);
           }
         },
       );
-      updateHashStamp(thingsHsm, thingsHash, thingsTime);
+      stampUpdate(thingsStampMap, thingsHash, thingsTime);
     }
-    return [oldThingsHash, thingsHsm[2]];
+    return [oldThingsHash, thingsStampMap[2]];
   };
   const preFinishTransaction = () => {
     if (listening) {
@@ -1848,26 +1924,118 @@ const createMergeableStore = (id) => {
   };
   const postFinishTransaction = () =>
     (transactionTime = transactionMergeableChanges = void 0);
-  const getMergeableContent = () =>
-    hashStampMap(contentHsm, ([tables, values]) => [
-      hashStampMapToObj(tables, (table) =>
-        hashStampMapToObj(table, (row) => hashStampMapToObj(row)),
+  const getId = () => id;
+  const getMergeableContent = () => [
+    contentStampMap[0],
+    [
+      stampMapToObjWithHash(contentStampMap[1][0], (tableStampMap) =>
+        stampMapToObjWithHash(tableStampMap, (rowStampMap) =>
+          stampMapToObjWithHash(rowStampMap),
+        ),
       ),
-      hashStampMapToObj(values),
-    ]);
-  const setMergeableContent = (mergeableContent) => {
-    disableListening(() =>
-      store.transaction(() => {
-        store.delTables().delValues();
-        contentHsm = newContentHsm();
-      }),
+      stampMapToObjWithHash(contentStampMap[1][1]),
+    ],
+    contentStampMap[2],
+  ];
+  const getMergeableContentHashes = () => [
+    contentStampMap[0],
+    [contentStampMap[1][0][2], contentStampMap[1][1][2]],
+  ];
+  const getMergeableTableHashes = () =>
+    mapToObj(contentStampMap[1][0][1], getStampHash);
+  const getMergeableTableIdsDiff = (relativeTo) => {
+    const tableIds = [];
+    mapForEach(contentStampMap[1][0][1], (tableId, [, , hash]) => {
+      if (hash !== relativeTo?.[tableId]) {
+        arrayPush(tableIds, tableId);
+      }
+    });
+    return tableIds;
+  };
+  const getMergeableRowHashes = (tablesDelta) =>
+    objNew(
+      arrayMap(tablesDelta, (tableId) => [
+        tableId,
+        mapToObj(mapGet(contentStampMap[1][0][1], tableId)?.[1], getStampHash),
+      ]),
     );
-    seenHlc(mergeableContent[0]);
-    disableListening(() =>
-      store.applyChanges(mergeContentOrChanges(mergeableContent, 1)),
+  const getMergeableRowIdsDiff = (relativeTo) =>
+    objMap(relativeTo, (rowHashes, tableId) => {
+      const rowIds = [];
+      mapForEach(
+        mapGet(contentStampMap[1][0][1], tableId)?.[1],
+        (rowId, [, , hash]) => {
+          if (hash !== rowHashes?.[rowId]) {
+            arrayPush(rowIds, rowId);
+          }
+        },
+      );
+      return rowIds;
+    });
+  const getMergeableCellHashes = (tableDelta) =>
+    objMap(tableDelta, (rowIds, tableId) =>
+      objNew(
+        arrayMap(rowIds, (rowId) => [
+          rowId,
+          mapToObj(
+            mapGet(mapGet(contentStampMap[1][0][1], tableId)?.[1], rowId)?.[1],
+            getStampHash,
+          ),
+        ]),
+      ),
     );
-    return mergeableStore;
+  const getMergeableTablesChanges = (relativeTo) => {
+    const [, [[tablesTime, tableStampMaps]]] = contentStampMap;
+    const tables = {};
+    objForEach(relativeTo, (rowCellHashes, tableId) =>
+      ifNotUndefined(
+        mapGet(tableStampMaps, tableId),
+        ([tableTime, rowStampMaps]) => {
+          const table = {};
+          objForEach(rowCellHashes, (cellHashes, rowId) =>
+            ifNotUndefined(
+              mapGet(rowStampMaps, rowId),
+              ([rowTime, cellStampMaps]) => {
+                const row = mapToObj(
+                  cellStampMaps,
+                  stampClone,
+                  ([, , hash], cellId) => hash == cellHashes?.[cellId],
+                );
+                if (!objIsEmpty(row)) {
+                  table[rowId] = [rowTime, row];
+                }
+              },
+            ),
+          );
+          if (!objIsEmpty(table)) {
+            tables[tableId] = [tableTime, table];
+          }
+        },
+      ),
+    );
+    return [tablesTime, tables];
   };
+  const getMergeableValuesHashes = () =>
+    mapToObj(contentStampMap[1][1][1], getStampHash);
+  const getMergeableValuesChanges = (relativeTo) => [
+    contentStampMap[1][1][0],
+    mapToObj(
+      contentStampMap[1][1][1],
+      stampClone,
+      ([, , hash], valueId) => hash == relativeTo?.[valueId],
+    ),
+  ];
+  const setMergeableContent = (mergeableContent) =>
+    disableListening(() =>
+      validateMergeableContent(mergeableContent)
+        ? store.transaction(() => {
+            store.delTables().delValues();
+            contentStampMap = newContentStampMap();
+            seenHlc(mergeableContent[0]);
+            store.applyChanges(mergeContentOrChanges(mergeableContent, 1));
+          })
+        : 0,
+    );
   const getTransactionMergeableChanges = () => {
     if (isUndefined(transactionMergeableChanges)) {
       const [, , changedCells, , changedValues] = store.getTransactionLog();
@@ -1875,10 +2043,14 @@ const createMergeableStore = (id) => {
         !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 mergeableChanges = [
+        time,
+        [
+          stampNewObj(objIsEmpty(changedCells) ? EMPTY_STRING : time),
+          stampNewObj(objIsEmpty(changedValues) ? EMPTY_STRING : time),
+          1,
+        ],
+      ];
       const [[, tablesObj], [, valuesObj]] = mergeableChanges[1];
       objToArray(changedCells, (changedTable, tableId) => {
         const [, rowsObj] = (tablesObj[tableId] = stampNewObj(time));
@@ -1886,60 +2058,45 @@ const createMergeableStore = (id) => {
           const [, cellsObj] = (rowsObj[rowId] = stampNewObj(time));
           objToArray(
             changedRow,
-            ([, newCell], cellId) =>
-              (cellsObj[cellId] = stampNew(time, newCell)),
+            ([, newCell], cellId) => (cellsObj[cellId] = [time, newCell]),
           );
         });
       });
       objToArray(
         changedValues,
-        ([, newValue], valueId) =>
-          (valuesObj[valueId] = stampNew(time, newValue)),
+        ([, newValue], valueId) => (valuesObj[valueId] = [time, newValue]),
       );
       return mergeableChanges;
     }
     return transactionMergeableChanges;
   };
-  const applyMergeableChanges = (mergeableChanges) => {
-    seenHlc(mergeableChanges[0]);
-    disableListening(() =>
-      store.applyChanges(mergeContentOrChanges(mergeableChanges)),
-    );
-    return mergeableStore;
-  };
+  const applyMergeableChanges = (mergeableChanges) =>
+    disableListening(() => {
+      seenHlc(mergeableChanges[0]);
+      store.applyChanges(mergeContentOrChanges(mergeableChanges));
+    });
   const merge = (mergeableStore2) => {
     const mergeableChanges = getMergeableContent();
     const mergeableChanges2 = mergeableStore2.getMergeableContent();
     mergeableStore2.applyMergeableChanges(mergeableChanges);
     return applyMergeableChanges(mergeableChanges2);
   };
-  const getContentHash = () => contentHsm[2];
-  const getTablesHash = () => contentHsm[1][0][2];
-  const getTableHash = (tableId) =>
-    mapGet(contentHsm[1][0][1], tableId)?.[2] ?? 0;
-  const getRowHash = (tableId, rowId) =>
-    mapGet(mapGet(contentHsm[1][0][1], tableId)?.[1], rowId)?.[2] ?? 0;
-  const getCellHash = (tableId, rowId, cellId) =>
-    mapGet(
-      mapGet(mapGet(contentHsm[1][0][1], tableId)?.[1], rowId)?.[1],
-      cellId,
-    )?.[2] ?? 0;
-  const getValuesHash = () => contentHsm[1][1][2];
-  const getValueHash = (valueId) =>
-    mapGet(contentHsm[1][1][1], valueId)?.[2] ?? 0;
   const mergeableStore = {
+    getId,
     getMergeableContent,
+    getMergeableContentHashes,
+    getMergeableTableHashes,
+    getMergeableTableIdsDiff,
+    getMergeableRowHashes,
+    getMergeableRowIdsDiff,
+    getMergeableCellHashes,
+    getMergeableTablesChanges,
+    getMergeableValuesHashes,
+    getMergeableValuesChanges,
     setMergeableContent,
     getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
-    getContentHash,
-    getTablesHash,
-    getTableHash,
-    getRowHash,
-    getCellHash,
-    getValuesHash,
-    getValueHash,
   };
   store.setInternalListeners(preFinishTransaction, postFinishTransaction);
   objToArray(