tinybase 6.2.0-beta.3 → 6.2.0

package/mergeable-store/index.js

@@ -97,21 +97,10 @@ const collClear = (coll) => coll.clear();
 const collForEach = (coll, cb) => coll?.forEach(cb);
 const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
-const textEncoder = /* @__PURE__ */ new GLOBAL.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 object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
-const objEntries = object.entries;
 const objFrozen = object.isFrozen;
+const objEntries = object.entries;
 const isObject = (obj) =>
   !isUndefined(obj) &&
   ifNotUndefined(
@@ -163,6 +152,29 @@ const objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
   return emptyIsValid ? true : !objIsEmpty(obj);
 };
 
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
+const jsonStringWithMap = (obj) =>
+  jsonString(obj, (_key, value) =>
+    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
+  );
+
+const textEncoder = /* @__PURE__ */ new GLOBAL.TextEncoder();
+const getHash = (string) => {
+  let hash = 2166136261;
+  arrayForEach(textEncoder.encode(string), (char) => {
+    hash ^= char;
+    hash +=
+      (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  });
+  return hash >>> 0;
+};
+const addOrRemoveHash = (hash1, hash2) => (hash1 ^ hash2) >>> 0;
+const getValueInValuesHash = (valueId, valueHash) =>
+  getHash(valueId + ':' + valueHash);
+const getValueHash = (value, valueHlc) =>
+  getHash(jsonStringWithMap(value ?? null) + ':' + valueHlc);
+
 const mapNew = (entries) => new Map(entries);
 const mapKeys = (map) => [...(map?.keys() ?? [])];
 const mapGet = (map, key) => map?.get(key);
@@ -341,13 +353,6 @@ const getHlcFunctions = (uniqueId, getNow = Date.now) => {
   ];
 };
 
-const jsonString = JSON.stringify;
-const jsonParse = JSON.parse;
-const jsonStringWithMap = (obj) =>
-  jsonString(obj, (_key, value) =>
-    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
-  );
-
 const setNew = (entryOrEntries) =>
   new Set(
     isArray(entryOrEntries) || isUndefined(entryOrEntries)
@@ -356,31 +361,30 @@ const setNew = (entryOrEntries) =>
   );
 const setAdd = (set, value) => set?.add(value);
 
-const stampClone = ([value, time]) => stampNew(value, time);
-const stampCloneWithHash = ([value, time, hash]) => [value, time, hash];
-const stampNew = (value, time) => (time ? [value, time] : [value]);
-const stampNewWithHash = (value, time, hash) => [value, time, hash];
+const stampClone = ([value, hlc]) => stampNew(value, hlc);
+const stampCloneWithHash = ([value, hlc, hash]) => [value, hlc, hash];
+const stampNew = (value, hlc) => (hlc ? [value, hlc] : [value]);
+const stampNewWithHash = (value, hlc, hash) => [value, hlc, hash];
 const getStampHash = (stamp) => stamp[2];
-const hashIdAndHash = (id, hash) => getHash(id + ':' + hash);
-const replaceTimeHash = (oldTime, newTime) =>
-  newTime > oldTime ? (oldTime ? getHash(oldTime) : 0) ^ getHash(newTime) : 0;
-const getLatestTime = (time1, time2) =>
+const replaceHlcHash = (oldHlc, newHlc) =>
+  newHlc > oldHlc ? (oldHlc ? getHash(oldHlc) : 0) ^ getHash(newHlc) : 0;
+const getLatestHlc = (hlc1, hlc2) =>
   /* istanbul ignore next */
-  ((time1 ?? '') > (time2 ?? '') ? time1 : time2) ?? '';
-const stampUpdate = (stamp, time, hash) => {
-  if (time > stamp[1]) {
-    stamp[1] = time;
+  ((hlc1 ?? '') > (hlc2 ?? '') ? hlc1 : hlc2) ?? '';
+const stampUpdate = (stamp, hlc, hash) => {
+  if (hlc > stamp[1]) {
+    stamp[1] = hlc;
   }
   stamp[2] = hash >>> 0;
 };
-const stampNewObj = (time = EMPTY_STRING) => stampNew(objNew(), time);
-const stampNewMap = (time = EMPTY_STRING) => [mapNew(), time, 0];
+const stampNewObj = (hlc = EMPTY_STRING) => stampNew(objNew(), hlc);
+const stampNewMap = (hlc = EMPTY_STRING) => [mapNew(), hlc, 0];
 const stampMapToObjWithHash = (
-  [map, time, hash],
+  [map, hlc, hash],
   mapper = stampCloneWithHash,
-) => [mapToObj(map, mapper), time, hash];
-const stampMapToObjWithoutHash = ([map, time], mapper = stampClone) =>
-  stampNew(mapToObj(map, mapper), time);
+) => [mapToObj(map, mapper), hlc, hash];
+const stampMapToObjWithoutHash = ([map, hlc], mapper = stampClone) =>
+  stampNew(mapToObj(map, mapper), hlc);
 const stampValidate = (stamp, validateThing) =>
   isArray(stamp) &&
   size(stamp) == 3 &&
@@ -1914,25 +1918,25 @@ const createMergeableStore = (uniqueId, getNow) => {
     const tablesChanges = {};
     const valuesChanges = {};
     const [
-      [tablesObj, incomingTablesTime = EMPTY_STRING, incomingTablesHash = 0],
+      [tablesObj, incomingTablesHlc = EMPTY_STRING, incomingTablesHash = 0],
       values,
     ] = contentOrChanges;
     const [tablesStampMap, valuesStampMap] = contentStampMap;
-    const [tableStampMaps, oldTablesTime, oldTablesHash] = tablesStampMap;
+    const [tableStampMaps, oldTablesHlc, oldTablesHash] = tablesStampMap;
     let tablesHash = isContent ? incomingTablesHash : oldTablesHash;
-    let tablesTime = incomingTablesTime;
+    let tablesHlc = incomingTablesHlc;
     objForEach(
       tablesObj,
       (
-        [rowsObj, incomingTableTime = EMPTY_STRING, incomingTableHash = 0],
+        [rowsObj, incomingTableHlc = EMPTY_STRING, incomingTableHash = 0],
         tableId,
       ) => {
         const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);
-        const [rowStampMaps, oldTableTime, oldTableHash] = tableStampMap;
+        const [rowStampMaps, oldTableHlc, oldTableHash] = tableStampMap;
         let tableHash = isContent ? incomingTableHash : oldTableHash;
-        let tableTime = incomingTableTime;
+        let tableHlc = incomingTableHlc;
         objForEach(rowsObj, (row, rowId) => {
-          const [rowTime, oldRowHash, rowHash] = mergeCellsOrValues(
+          const [rowHlc, oldRowHash, rowHash] = mergeCellsOrValues(
             row,
             mapEnsure(rowStampMaps, rowId, stampNewMap),
             objEnsure(objEnsure(tablesChanges, tableId, objNew), rowId, objNew),
@@ -1940,32 +1944,36 @@ const createMergeableStore = (uniqueId, getNow) => {
           );
           tableHash ^= isContent
             ? 0
-            : (oldRowHash ? hashIdAndHash(rowId, oldRowHash) : 0) ^
-              hashIdAndHash(rowId, rowHash);
-          tableTime = getLatestTime(tableTime, rowTime);
+            : addOrRemoveHash(
+                oldRowHash ? getValueInValuesHash(rowId, oldRowHash) : 0,
+                getValueInValuesHash(rowId, rowHash),
+              );
+          tableHlc = getLatestHlc(tableHlc, rowHlc);
         });
         tableHash ^= isContent
           ? 0
-          : replaceTimeHash(oldTableTime, incomingTableTime);
-        stampUpdate(tableStampMap, incomingTableTime, tableHash);
+          : replaceHlcHash(oldTableHlc, incomingTableHlc);
+        stampUpdate(tableStampMap, incomingTableHlc, tableHash);
         tablesHash ^= isContent
           ? 0
-          : (oldTableHash ? hashIdAndHash(tableId, oldTableHash) : 0) ^
-            hashIdAndHash(tableId, tableStampMap[2]);
-        tablesTime = getLatestTime(tablesTime, tableTime);
+          : addOrRemoveHash(
+              oldTableHash ? getValueInValuesHash(tableId, oldTableHash) : 0,
+              getValueInValuesHash(tableId, tableStampMap[2]),
+            );
+        tablesHlc = getLatestHlc(tablesHlc, tableHlc);
       },
     );
     tablesHash ^= isContent
       ? 0
-      : replaceTimeHash(oldTablesTime, incomingTablesTime);
-    stampUpdate(tablesStampMap, incomingTablesTime, tablesHash);
-    const [valuesTime] = mergeCellsOrValues(
+      : replaceHlcHash(oldTablesHlc, incomingTablesHlc);
+    stampUpdate(tablesStampMap, incomingTablesHlc, tablesHash);
+    const [valuesHlc] = mergeCellsOrValues(
       values,
       valuesStampMap,
       valuesChanges,
       isContent,
     );
-    seenHlc(getLatestTime(tablesTime, valuesTime));
+    seenHlc(getLatestHlc(tablesHlc, valuesHlc));
     return [tablesChanges, valuesChanges, 1];
   };
   const mergeCellsOrValues = (
@@ -1976,44 +1984,44 @@ const createMergeableStore = (uniqueId, getNow) => {
   ) => {
     const [
       thingsObj,
-      incomingThingsTime = EMPTY_STRING,
+      incomingThingsHlc = EMPTY_STRING,
       incomingThingsHash = 0,
     ] = things;
-    const [thingStampMaps, oldThingsTime, oldThingsHash] = thingsStampMap;
-    let thingsTime = incomingThingsTime;
+    const [thingStampMaps, oldThingsHlc, oldThingsHash] = thingsStampMap;
+    let thingsHlc = incomingThingsHlc;
     let thingsHash = isContent ? incomingThingsHash : oldThingsHash;
     objForEach(
       thingsObj,
-      ([thing, thingTime = EMPTY_STRING, incomingThingHash = 0], thingId) => {
+      ([thing, thingHlc = EMPTY_STRING, incomingThingHash = 0], thingId) => {
         const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [
           void 0,
           EMPTY_STRING,
           0,
         ]);
-        const [, oldThingTime, oldThingHash] = thingStampMap;
-        if (!oldThingTime || thingTime > oldThingTime) {
+        const [, oldThingHlc, oldThingHash] = thingStampMap;
+        if (!oldThingHlc || thingHlc > oldThingHlc) {
           stampUpdate(
             thingStampMap,
-            thingTime,
-            isContent
-              ? incomingThingHash
-              : getHash(jsonStringWithMap(thing ?? null) + ':' + thingTime),
+            thingHlc,
+            isContent ? incomingThingHash : getValueHash(thing, thingHlc),
           );
           thingStampMap[0] = thing;
           thingsChanges[thingId] = thing;
           thingsHash ^= isContent
             ? 0
-            : hashIdAndHash(thingId, oldThingHash) ^
-              hashIdAndHash(thingId, thingStampMap[2]);
-          thingsTime = getLatestTime(thingsTime, thingTime);
+            : addOrRemoveHash(
+                getValueInValuesHash(thingId, oldThingHash),
+                getValueInValuesHash(thingId, thingStampMap[2]),
+              );
+          thingsHlc = getLatestHlc(thingsHlc, thingHlc);
         }
       },
     );
     thingsHash ^= isContent
       ? 0
-      : replaceTimeHash(oldThingsTime, incomingThingsTime);
-    stampUpdate(thingsStampMap, incomingThingsTime, thingsHash);
-    return [thingsTime, oldThingsHash, thingsStampMap[2]];
+      : replaceHlcHash(oldThingsHlc, incomingThingsHlc);
+    stampUpdate(thingsStampMap, incomingThingsHlc, thingsHash);
+    return [thingsHlc, oldThingsHash, thingsStampMap[2]];
   };
   const preStartTransaction = noop;
   const preFinishTransaction = noop;
@@ -2085,13 +2093,13 @@ const createMergeableStore = (uniqueId, getNow) => {
     const differingTableHashes = {};
     mapForEach(
       contentStampMap[0][0],
-      (tableId, [tableStampMap, tableTime, hash]) =>
+      (tableId, [tableStampMap, tableHlc, hash]) =>
         objHas(otherTableHashes, tableId)
           ? hash != otherTableHashes[tableId]
             ? (differingTableHashes[tableId] = hash)
             : 0
           : (newTables[0][tableId] = stampMapToObjWithoutHash(
-              [tableStampMap, tableTime],
+              [tableStampMap, tableHlc],
               (rowStampMap) => stampMapToObjWithoutHash(rowStampMap),
             )),
     );
@@ -2120,13 +2128,13 @@ const createMergeableStore = (uniqueId, getNow) => {
     objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>
       mapForEach(
         mapGet(contentStampMap[0][0], tableId)?.[0],
-        (rowId, [rowStampMap, rowTime, hash]) =>
+        (rowId, [rowStampMap, rowHlc, hash]) =>
           objHas(otherRowHashes, rowId)
             ? hash !== otherRowHashes[rowId]
               ? (objEnsure(differingRowHashes, tableId, objNew)[rowId] = hash)
               : 0
             : (objEnsure(newRows[0], tableId, stampNewObj)[0][rowId] =
-                stampMapToObjWithoutHash([rowStampMap, rowTime])),
+                stampMapToObjWithoutHash([rowStampMap, rowHlc])),
       ),
     );
     return [newRows, differingRowHashes];
@@ -2157,43 +2165,43 @@ const createMergeableStore = (uniqueId, getNow) => {
     return cellHashes;
   };
   const getMergeableCellDiff = (otherTableRowCellHashes) => {
-    const [[tableStampMaps, tablesTime]] = contentStampMap;
+    const [[tableStampMaps, tablesHlc]] = contentStampMap;
     const tablesObj = {};
     objForEach(otherTableRowCellHashes, (otherRowCellHashes, tableId) =>
       objForEach(otherRowCellHashes, (otherCellHashes, rowId) =>
         ifNotUndefined(
           mapGet(tableStampMaps, tableId),
-          ([rowStampMaps, tableTime]) =>
+          ([rowStampMaps, tableHlc]) =>
             ifNotUndefined(
               mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowTime]) =>
-                mapForEach(cellStampMaps, (cellId, [cell, cellTime, hash]) =>
+              ([cellStampMaps, rowHlc]) =>
+                mapForEach(cellStampMaps, (cellId, [cell, cellHlc, hash]) =>
                   hash !== otherCellHashes[cellId]
                     ? (objEnsure(
                         objEnsure(tablesObj, tableId, () =>
-                          stampNewObj(tableTime),
+                          stampNewObj(tableHlc),
                         )[0],
                         rowId,
-                        () => stampNewObj(rowTime),
-                      )[0][cellId] = [cell, cellTime])
+                        () => stampNewObj(rowHlc),
+                      )[0][cellId] = [cell, cellHlc])
                     : 0,
                 ),
             ),
         ),
       ),
     );
-    return stampNew(tablesObj, tablesTime);
+    return stampNew(tablesObj, tablesHlc);
   };
   const getMergeableValueHashes = () =>
     mapToObj(contentStampMap[1][0], getStampHash);
   const getMergeableValueDiff = (otherValueHashes) => {
-    const [, [valueStampMaps, valuesTime]] = contentStampMap;
+    const [, [valueStampMaps, valuesHlc]] = contentStampMap;
     const values = mapToObj(
       valueStampMaps,
       stampClone,
       ([, , hash], valueId) => hash == otherValueHashes?.[valueId],
     );
-    return stampNew(values, valuesTime);
+    return stampNew(values, valuesHlc);
   };
   const setMergeableContent = (mergeableContent) =>
     disableListeningToRawStoreChanges(() =>
@@ -2215,20 +2223,20 @@ const createMergeableStore = (uniqueId, getNow) => {
   };
   const getTransactionMergeableChanges = (withHashes = false) => {
     const [
-      [tableStampMaps, tablesTime, tablesHash],
-      [valueStampMaps, valuesTime, valuesHash],
+      [tableStampMaps, tablesHlc, tablesHash],
+      [valueStampMaps, valuesHlc, valuesHash],
     ] = contentStampMap;
     const newStamp = withHashes ? stampNewWithHash : stampNew;
     const tablesObj = {};
     collForEach(touchedCells, (touchedTable, tableId) =>
       ifNotUndefined(
         mapGet(tableStampMaps, tableId),
-        ([rowStampMaps, tableTime, tableHash]) => {
+        ([rowStampMaps, tableHlc, tableHash]) => {
           const tableObj = {};
           collForEach(touchedTable, (touchedRow, rowId) =>
             ifNotUndefined(
               mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowTime, rowHash]) => {
+              ([cellStampMaps, rowHlc, rowHash]) => {
                 const rowObj = {};
                 collForEach(touchedRow, (cellId) => {
                   ifNotUndefined(
@@ -2237,11 +2245,11 @@ const createMergeableStore = (uniqueId, getNow) => {
                       (rowObj[cellId] = newStamp(cell, time, hash)),
                   );
                 });
-                tableObj[rowId] = newStamp(rowObj, rowTime, rowHash);
+                tableObj[rowId] = newStamp(rowObj, rowHlc, rowHash);
               },
             ),
           );
-          tablesObj[tableId] = newStamp(tableObj, tableTime, tableHash);
+          tablesObj[tableId] = newStamp(tableObj, tableHlc, tableHash);
         },
       ),
     );
@@ -2254,8 +2262,8 @@ const createMergeableStore = (uniqueId, getNow) => {
       ),
     );
     return [
-      newStamp(tablesObj, tablesTime, tablesHash),
-      newStamp(valuesObj, valuesTime, valuesHash),
+      newStamp(tablesObj, tablesHlc, tablesHash),
+      newStamp(valuesObj, valuesHlc, valuesHash),
       1,
     ];
   };