tinybase 5.0.0-beta.4 → 5.0.0-beta.5

package/lib/debug/mergeable-store.js

@@ -24,8 +24,7 @@ const VALUE_IDS = VALUE + IDS;
 const id = (key) => EMPTY_STRING + key;
 const strStartsWith = (str, prefix) => str.startsWith(prefix);
 const strEndsWith = (str, suffix) => str.endsWith(suffix);
-const strSplit = (str, separator = '', limit) => str.split(separator, limit);
-const strCharCodeAt = (str, position = 0) => str.charCodeAt(position);
+const strCharCodeAt = (str, position) => str.charCodeAt(position);
 
 const mathMax = Math.max;
 const isFiniteNumber = isFinite;
@@ -80,6 +79,12 @@ const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+const objEnsure = (obj, id, getDefaultValue) => {
+  if (!objHas(obj, id)) {
+    obj[id] = getDefaultValue();
+  }
+  return obj[id];
+};
 
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
@@ -103,9 +108,11 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };
@@ -163,36 +170,36 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
-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(
-      newThingStamp,
-      mapEnsure(thingStamps, thingId, stampNewMap),
-      (changes[thingId] = objNew()),
-      merge,
-    ),
-  );
-const mergeStamp = ([newTime, newThing], thingStamp, changes, merge) => {
-  if (newTime > thingStamp[0]) {
-    thingStamp[0] = newTime;
+const textEncoder = new globalThis.TextEncoder();
+const getHash = (value) => {
+  let hash = 2166136261;
+  arrayForEach(textEncoder.encode(value), (char) => {
+    hash ^= char;
+    hash +=
+      (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  });
+  return hash >>> 0;
+};
+
+const cloneHashStamp = ([time, value, hash]) => [time, value, hash];
+const stampNew = (time, thing) => [time, thing];
+const hashIdAndHash = (id, hash) => getHash(id + ':' + hash);
+const updateHashStamp = (hashStamp, hash, time) => {
+  hashStamp[2] = hash >>> 0;
+  if (time > hashStamp[0]) {
+    hashStamp[0] = time;
   }
-  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 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 setNew = (entryOrEntries) =>
   new Set(
@@ -292,9 +299,10 @@ const pairNewMap = () => [mapNew(), mapNew()];
 const pairClone = (array) => [...array];
 const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
 
-const getCellOrValueType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+const getCellOrValueType = (cellOrValue) => {
+  const type = getTypeOf(cellOrValue);
+  return isTypeStringOrBoolean(type) ||
+    (type == NUMBER && isFiniteNumber(cellOrValue))
     ? type
     : void 0;
 };
@@ -1637,12 +1645,6 @@ const SHIFT12 = 2 ** 12;
 const SHIFT6 = 2 ** 6;
 const toB64 = (num) => String.fromCharCode(48 + (num & MASK6));
 const fromB64 = (str, pos) => strCharCodeAt(str, pos) - 48;
-const hash = (value) =>
-  arrayReduce(
-    strSplit(value),
-    (hash2, char) => ((hash2 << 5) + hash2) ^ strCharCodeAt(char),
-    5381,
-  ) >>> 0;
 const encodeHlc = (logicalTime42, counter24, clientHash30) =>
   toB64(logicalTime42 / SHIFT36) +
   toB64(logicalTime42 / SHIFT30) +
@@ -1681,7 +1683,7 @@ const decodeHlc = (hlc16) => [
 const getHlcFunctions = (uniqueId) => {
   let logicalTime = 0;
   let lastCounter = -1;
-  const uniqueIdHash = hash(uniqueId);
+  const uniqueIdHash = getHash(uniqueId);
   const getHlc = () => {
     seenHlc();
     return encodeHlc(logicalTime, ++lastCounter, uniqueIdHash);
@@ -1722,15 +1724,16 @@ const LISTENER_ARGS = {
   InvalidCell: 3,
   InvalidValue: 1,
 };
-const newContentStamp = (time = EMPTY_STRING) => [
+const newContentHsm = (time = EMPTY_STRING) => [
   time,
-  [stampNewMap(time), stampNewMap(time)],
+  [hashStampNewMap(time), hashStampNewMap(time)],
+  0,
 ];
 const createMergeableStore = (id) => {
   let listening = 1;
-  let contentStamp = newContentStamp();
+  let contentHsm = newContentHsm();
   let transactionTime;
-  let finishTransactionMergeableChanges;
+  let transactionMergeableChanges;
   const [getHlc, seenHlc] = getHlcFunctions(id);
   const store = createStore();
   const disableListening = (actions) => {
@@ -1739,68 +1742,134 @@ const createMergeableStore = (id) => {
     actions();
     listening = wasListening;
   };
-  const preFinishTransaction = () => {
-    if (listening) {
-      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 (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)),
+  const mergeContentOrChanges = (contentOrChanges, hasHashes = 0) => {
+    const tablesChanges = {};
+    const valuesChanges = {};
+    const [
+      contentOrChangesTime,
+      [[tablesTime, tablesObj, incomingTablesHash], values],
+      incomingContentOrChangesHash,
+    ] = contentOrChanges;
+    const [, [tablesHsm, valuesHsm]] = contentHsm;
+    const [oldTablesTime, tableHsms, oldTablesHash] = tablesHsm;
+    if (tablesTime) {
+      let tablesHash = hasHashes
+        ? incomingTablesHash
+        : oldTablesHash ^
+          (tablesTime > oldTablesTime
+            ? (oldTablesTime ? getHash(oldTablesTime) : 0) ^ getHash(tablesTime)
+            : 0);
+      objForEach(
+        tablesObj,
+        ([tableTime, rowsObj, incomingTableHash], tableId) => {
+          const tableHsm = mapEnsure(tableHsms, tableId, hashStampNewMap);
+          const [oldTableTime, rowHsms, oldTableHash] = tableHsm;
+          let tableHash = hasHashes
+            ? incomingTableHash
+            : oldTableHash ^
+              (tableTime > oldTableTime
+                ? (oldTableTime ? getHash(oldTableTime) : 0) ^
+                  getHash(tableTime)
+                : 0);
+          objForEach(rowsObj, (row, rowId) => {
+            const [oldRowHash, rowHash] = mergeCellsOrValues(
+              row,
+              mapEnsure(rowHsms, rowId, hashStampNewMap),
+              objEnsure(
+                objEnsure(tablesChanges, tableId, objNew),
+                rowId,
+                objNew,
+              ),
+              hasHashes,
             );
+            tableHash ^= hasHashes
+              ? 0
+              : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
+                hashIdAndHash(rowId, rowHash);
           });
-        });
-      }
-      if (valuesTouched) {
-        valuesStamp[0] = time;
-        objToArray(changedValuesStamp[1], ([, newValue], valueId) =>
-          mapSet(valuesStamp[1], valueId, stampNew(time, newValue)),
-        );
-      }
+          updateHashStamp(tableHsm, tableHash, tableTime);
+          tablesHash ^= hasHashes
+            ? 0
+            : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
+              hashIdAndHash(tableId, tableHsm[2]);
+        },
+      );
+      updateHashStamp(tablesHsm, tablesHash, tablesTime);
     }
+    mergeCellsOrValues(values, valuesHsm, valuesChanges, hasHashes);
+    updateHashStamp(
+      contentHsm,
+      hasHashes ? incomingContentOrChangesHash : tablesHsm[2] ^ valuesHsm[2],
+      contentOrChangesTime,
+    );
+    return [tablesChanges, valuesChanges];
   };
-  const postFinishTransaction = () =>
-    (transactionTime = finishTransactionMergeableChanges = void 0);
-  const merge = (mergeableStore2) => {
-    const mergeableContent = mergeableStore.getMergeableContent();
-    const mergeableContent2 = mergeableStore2.getMergeableContent();
-    mergeableStore2.applyMergeableChanges(mergeableContent);
-    return applyMergeableChanges(mergeableContent2);
+  const mergeCellsOrValues = (things, thingsHsm, thingsChanges, hasHashes) => {
+    const [thingsTime, thingsObj, incomingThingsHash] = things;
+    const [oldThingsTime, thingHsms, oldThingsHash] = thingsHsm;
+    if (thingsTime) {
+      let thingsHash = hasHashes
+        ? incomingThingsHash
+        : oldThingsHash ^
+          (thingsTime > oldThingsTime
+            ? (oldThingsTime ? getHash(oldThingsTime) : 0) ^ getHash(thingsTime)
+            : 0);
+      objForEach(
+        thingsObj,
+        ([thingTime, thing, incomingThingHash], thingId) => {
+          const thingHsm = mapEnsure(thingHsms, thingId, hashStampNewThing);
+          const [oldThingTime, , oldThingHash] = thingHsm;
+          if (thingTime > oldThingTime) {
+            updateHashStamp(
+              thingHsm,
+              hasHashes
+                ? incomingThingHash
+                : getHash(jsonString(thing ?? null) + ':' + thingTime),
+              thingTime,
+            );
+            thingHsm[1] = thing;
+            thingsChanges[thingId] = thing;
+            thingsHash ^= hasHashes
+              ? 0
+              : hashIdAndHash(thingId, oldThingHash) ^
+                hashIdAndHash(thingId, thingHsm[2]);
+          }
+        },
+      );
+      updateHashStamp(thingsHsm, thingsHash, thingsTime);
+    }
+    return [oldThingsHash, thingsHsm[2]];
   };
+  const preFinishTransaction = () => {
+    if (listening) {
+      transactionMergeableChanges = getTransactionMergeableChanges();
+      mergeContentOrChanges(transactionMergeableChanges);
+    }
+  };
+  const postFinishTransaction = () =>
+    (transactionTime = transactionMergeableChanges = void 0);
   const getMergeableContent = () =>
-    mapStamp(contentStamp, ([tablesStamp, valuesStamp]) => [
-      mapStampMapToObj(tablesStamp, (rowsStamp) =>
-        mapStampMapToObj(rowsStamp, (cellsStamp) =>
-          mapStampMapToObj(cellsStamp, cloneStamp),
-        ),
+    hashStampMap(contentHsm, ([tables, values]) => [
+      hashStampMapToObj(tables, (table) =>
+        hashStampMapToObj(table, (row) => hashStampMapToObj(row)),
       ),
-      mapStampMapToObj(valuesStamp, cloneStamp),
+      hashStampMapToObj(values),
     ]);
   const setMergeableContent = (mergeableContent) => {
     disableListening(() =>
       store.transaction(() => {
         store.delTables().delValues();
-        contentStamp = newContentStamp();
+        contentHsm = newContentHsm();
       }),
     );
-    applyMergeableChanges(mergeableContent);
+    seenHlc(mergeableContent[0]);
+    disableListening(() =>
+      store.applyChanges(mergeContentOrChanges(mergeableContent, 1)),
+    );
     return mergeableStore;
   };
   const getTransactionMergeableChanges = () => {
-    if (isUndefined(finishTransactionMergeableChanges)) {
+    if (isUndefined(transactionMergeableChanges)) {
       const [, , changedCells, , changedValues] = store.getTransactionLog();
       const time =
         !objIsEmpty(changedCells) || !objIsEmpty(changedValues)
@@ -1810,69 +1879,67 @@ const createMergeableStore = (id) => {
         stampNewObj(objIsEmpty(changedCells) ? EMPTY_STRING : time),
         stampNewObj(objIsEmpty(changedValues) ? EMPTY_STRING : time),
       ]);
-      const [[, tableStamps], [, valuesStamp]] = mergeableChanges[1];
+      const [[, tablesObj], [, valuesObj]] = mergeableChanges[1];
       objToArray(changedCells, (changedTable, tableId) => {
-        const [, rowStamps] = (tableStamps[tableId] = stampNewObj(time));
+        const [, rowsObj] = (tablesObj[tableId] = stampNewObj(time));
         objToArray(changedTable, (changedRow, rowId) => {
-          const [, cellStamps] = (rowStamps[rowId] = stampNewObj(time));
+          const [, cellsObj] = (rowsObj[rowId] = stampNewObj(time));
           objToArray(
             changedRow,
             ([, newCell], cellId) =>
-              (cellStamps[cellId] = stampNew(time, newCell)),
+              (cellsObj[cellId] = stampNew(time, newCell)),
           );
         });
       });
       objToArray(
         changedValues,
         ([, newValue], valueId) =>
-          (valuesStamp[valueId] = stampNew(time, newValue)),
+          (valuesObj[valueId] = stampNew(time, newValue)),
       );
       return mergeableChanges;
     }
-    return finishTransactionMergeableChanges;
+    return transactionMergeableChanges;
   };
-  const applyMergeableChanges = (newContentStamp2) => {
-    const changes = [{}, {}];
-    seenHlc(newContentStamp2[0]);
-    mergeStamp(
-      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);
-      },
+  const applyMergeableChanges = (mergeableChanges) => {
+    seenHlc(mergeableChanges[0]);
+    disableListening(() =>
+      store.applyChanges(mergeContentOrChanges(mergeableChanges)),
     );
-    disableListening(() => store.applyChanges(changes));
     return mergeableStore;
   };
+  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 = {
     getMergeableContent,
     setMergeableContent,
     getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
+    getContentHash,
+    getTablesHash,
+    getTableHash,
+    getRowHash,
+    getCellHash,
+    getValuesHash,
+    getValueHash,
   };
   store.setInternalListeners(preFinishTransaction, postFinishTransaction);
   objToArray(

package/lib/debug/metrics.js

@@ -52,9 +52,11 @@ const mapForEach = (map, cb) =>
   collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-automerge.js

@@ -52,9 +52,11 @@ const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-browser.js

@@ -42,9 +42,11 @@ const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-cr-sqlite-wasm.js

@@ -75,9 +75,11 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-electric-sql.js

@@ -76,9 +76,11 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-expo-sqlite-next.js

@@ -77,9 +77,11 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-expo-sqlite.js

@@ -75,9 +75,11 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-file.js

@@ -46,9 +46,11 @@ const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };

package/lib/debug/persisters/persister-indexed-db.js

@@ -51,9 +51,11 @@ const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };