tinybase 6.2.0-beta.3 → 6.2.0

package/index.js

@@ -118,8 +118,8 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
 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(
@@ -785,16 +785,56 @@ const getUniqueId = (length = 16) =>
     '',
   );
 
+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 = (value) => {
+const getHash = (string) => {
   let hash = 2166136261;
-  arrayForEach(textEncoder.encode(value), (char) => {
+  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 getValuesHash = (valueHashes) =>
+  arrayReduce(
+    objEntries(valueHashes),
+    (valuesHash, [valueId, valueHash]) =>
+      addOrRemoveHash(
+        valuesHash,
+        getValueInValuesHash(valueId, valueHash) ^
+          getValueInValuesHash(valueId, 0),
+        // legacy v5; remove in v7
+      ),
+    0,
+    // legacy v5; valuesHlc in v7?
+  );
+const getValueInValuesHash = (valueId, valueHash) =>
+  getHash(valueId + ':' + valueHash);
+const getValueHash = (value, valueHlc) =>
+  getHash(jsonStringWithMap(value ?? null) + ':' + valueHlc);
+const getCellHash = getValueHash;
+const getCellInRowHash = getValueInValuesHash;
+const getRowHash = getValuesHash;
+const getRowInTableHash = getValueInValuesHash;
+const getTableHash = (rowHashes) =>
+  // alias to getValuesHash in v7
+  arrayReduce(
+    objEntries(rowHashes),
+    (valuesHash, [rowId, rowHash]) =>
+      addOrRemoveHash(valuesHash, getValueInValuesHash(rowId, rowHash)),
+    0,
+    // legacy v5; rowHlc in v7?
+  );
+const getTableInTablesHash = getValueInValuesHash;
+const getTablesHash = getTableHash;
 
 const SHIFT36 = 2 ** 36;
 const SHIFT30 = 2 ** 30;
@@ -1090,38 +1130,30 @@ const createIndexes = getCreateFunction((store) => {
   return objFreeze(indexes);
 });
 
-const jsonString = JSON.stringify;
-const jsonParse = JSON.parse;
-const jsonStringWithMap = (obj) =>
-  jsonString(obj, (_key, value) =>
-    isInstanceOf(value, Map) ? object.fromEntries([...value]) : 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 &&
@@ -2566,25 +2598,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),
@@ -2592,32 +2624,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 = (
@@ -2628,44 +2664,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;
@@ -2737,13 +2773,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),
             )),
     );
@@ -2772,13 +2808,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];
@@ -2809,43 +2845,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(() =>
@@ -2867,20 +2903,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(
@@ -2889,11 +2925,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);
         },
       ),
     );
@@ -2906,8 +2942,8 @@ const createMergeableStore = (uniqueId, getNow) => {
       ),
     );
     return [
-      newStamp(tablesObj, tablesTime, tablesHash),
-      newStamp(valuesObj, valuesTime, valuesHash),
+      newStamp(tablesObj, tablesHlc, tablesHash),
+      newStamp(valuesObj, valuesHlc, valuesHash),
       1,
     ];
   };
@@ -3795,6 +3831,7 @@ const createRelationships = getCreateFunction((store) => {
 });
 
 export {
+  addOrRemoveHash,
   createCheckpoints,
   createIndexes,
   createMergeableStore,
@@ -3803,7 +3840,17 @@ export {
   createRelationships,
   createStore,
   defaultSorter,
+  getCellHash,
+  getCellInRowHash,
+  getHash,
   getHlcFunctions,
-  getRandomValues,
+  getRowHash,
+  getRowInTableHash,
+  getTableHash,
+  getTableInTablesHash,
+  getTablesHash,
   getUniqueId,
+  getValueHash,
+  getValueInValuesHash,
+  getValuesHash,
 };