tinybase 5.0.0-beta.1 → 5.0.0-beta.3

package/lib/debug/tinybase.js

@@ -29,6 +29,10 @@ const VALUE = 'Value';
 const VALUES = VALUE + 's';
 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 mathMax = Math.max;
 const mathMin = Math.min;
@@ -84,13 +88,15 @@ 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;
 };
-const objMap = (obj, cb) =>
+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 objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
@@ -124,7 +130,7 @@ const mapEnsure = (map, key, getDefaultValue) => {
   return mapGet(map, key);
 };
 const mapMatch = (map, obj, set, del = mapSet) => {
-  objMap(obj, (value, id) => set(map, id, value));
+  objToArray(obj, (value, id) => set(map, id, value));
   mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
   return map;
 };
@@ -1086,6 +1092,7 @@ const createCustomPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
+  supportsMergeableStore,
   [getThing, thing] = [],
   scheduleId = [],
 ) => {
@@ -1098,6 +1105,10 @@ const createCustomPersister = (
   let listeningHandle;
   mapEnsure(scheduleRunning, scheduleId, () => 0);
   mapEnsure(scheduleActions, scheduleId, () => []);
+  const getContent =
+    (supportsMergeableStore ? store.getMergeableContent : null) ??
+    store.getContent;
+  const getChanges = store.getTransactionChanges;
   const run = async () => {
     /* istanbul ignore else */
     if (!mapGet(scheduleRunning, scheduleId)) {
@@ -1133,7 +1144,10 @@ const createCustomPersister = (
     load: async (initialTables, initialValues) =>
       await loadLock(async () => {
         try {
-          store.setContent(await getPersisted());
+          const content = await getPersisted();
+          (supportsMergeableStore && isString(content[0])
+            ? store.applyMergeableChanges
+            : store.setContent)(content);
         } catch {
           store.setContent([initialTables, initialValues]);
         }
@@ -1143,16 +1157,14 @@ const createCustomPersister = (
       await persister.load(initialTables, initialValues);
       listening = 1;
       listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
-          if (getTransactionChanges) {
-            const transactionChanges = getTransactionChanges();
-            await loadLock(async () =>
-              store.setTransactionChanges(transactionChanges),
-            );
+        async (getContent2, getChanges2) => {
+          if (getChanges2) {
+            const changes = getChanges2();
+            await loadLock(async () => store.applyChanges(changes));
           } else {
             await loadLock(async () => {
               try {
-                store.setContent(getContent?.() ?? (await getPersisted()));
+                store.setContent(getContent2?.() ?? (await getPersisted()));
               } catch (error) {
                 onIgnoredError?.(error);
               }
@@ -1170,7 +1182,7 @@ const createCustomPersister = (
       }
       return persister;
     },
-    save: async (getTransactionChanges) => {
+    save: async (getChanges2) => {
       /* istanbul ignore else */
       if (loadSave != 1) {
         loadSave = 2;
@@ -1179,7 +1191,7 @@ const createCustomPersister = (
         }
         await persister.schedule(async () => {
           try {
-            await setPersisted(store.getContent, getTransactionChanges);
+            await setPersisted(getContent, getChanges2);
           } catch (error) {
             /* istanbul ignore next */
             onIgnoredError?.(error);
@@ -1191,14 +1203,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 [tableChanges, valueChanges] = getChanges();
+        if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
+          persister.save(() => [tableChanges, valueChanges]);
+        }
+      });
       return persister;
     },
     stopAutoSave: () => {
@@ -1648,7 +1658,7 @@ const createQueries = getCreateFunction((store) => {
     destroy,
     getListenerStats,
   };
-  objMap(
+  objToArray(
     {
       [TABLE]: [1, 1],
       [TABLE + CELL_IDS]: [0, 1],
@@ -1869,6 +1879,35 @@ const createRelationships = getCreateFunction((store) => {
   return objFreeze(relationships);
 });
 
+const stampNew = () => [EMPTY_STRING, void 0];
+const stampNewMap = () => [EMPTY_STRING, mapNew()];
+const mapStamp = ([stamp, value], mapper) => [stamp, mapper(value, stamp)];
+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;
+  }
+  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]);
 const pairNewMap = () => [mapNew(), mapNew()];
@@ -1886,7 +1925,7 @@ const validate = (obj, validateChild, onInvalidObj) => {
     onInvalidObj?.();
     return false;
   }
-  objMap(obj, (child, id2) => {
+  objToArray(obj, (child, id2) => {
     if (!validateChild(child, id2)) {
       objDel(obj, id2);
     }
@@ -1907,6 +1946,7 @@ const createStore = () => {
   let hadTables = false;
   let hadValues = false;
   let transactions = 0;
+  let postTransactionListener;
   const changedTableIds = mapNew();
   const changedTableCellIds = mapNew();
   const changedRowCount = mapNew();
@@ -2548,44 +2588,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);
@@ -2678,7 +2680,7 @@ const createStore = () => {
       (tableId2, rowId2) => {
         if (validateRow(tableId2, rowId2, partialRow, 1)) {
           const table = getOrCreateTable(tableId2);
-          objMap(partialRow, (cell, cellId) =>
+          objToArray(partialRow, (cell, cellId) =>
             setCellIntoDefaultRow(tableId2, table, rowId2, cellId, cell),
           );
         }
@@ -2716,7 +2718,7 @@ const createStore = () => {
   const setPartialValues = (partialValues) =>
     fluentTransaction(() =>
       validateValues(partialValues, 1)
-        ? objMap(partialValues, (value, valueId) =>
+        ? objToArray(partialValues, (value, valueId) =>
             setValidValue(valueId, value),
           )
         : 0,
@@ -2733,20 +2735,20 @@ const createStore = () => {
         ),
       valueId,
     );
-  const setTransactionChanges = (transactionChanges) =>
+  const applyChanges = (changes) =>
     fluentTransaction(() => {
-      objMap(transactionChanges[0], (table, tableId) =>
+      objToArray(changes[0], (table, tableId) =>
         isUndefined(table)
           ? delTable(tableId)
-          : objMap(table, (row, rowId) =>
+          : objToArray(table, (row, rowId) =>
               isUndefined(row)
                 ? delRow(tableId, rowId)
-                : objMap(row, (cell, cellId) =>
+                : objToArray(row, (cell, cellId) =>
                     setOrDelCell(store, tableId, rowId, cellId, cell),
                   ),
             ),
       );
-      objMap(transactionChanges[1], (value, valueId) =>
+      objToArray(changes[1], (value, valueId) =>
         setOrDelValue(store, valueId, value),
       );
     });
@@ -2873,15 +2875,48 @@ 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 = () => [
+    cellsTouched,
+    valuesTouched,
+    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--;
@@ -2897,7 +2932,7 @@ const createStore = () => {
         if (valuesTouched) {
           callValuesListenersForChanges(1);
         }
-        if (doRollback?.(getTransactionChanges, getTransactionLog)) {
+        if (doRollback?.(store)) {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
@@ -2910,12 +2945,7 @@ const createStore = () => {
           );
           cellsTouched = valuesTouched = false;
         }
-        callListeners(
-          finishTransactionListeners[0],
-          void 0,
-          getTransactionChanges,
-          getTransactionLog,
-        );
+        callListeners(finishTransactionListeners[0], void 0);
         transactions = -1;
         callInvalidCellListeners(0);
         if (cellsTouched) {
@@ -2925,12 +2955,8 @@ const createStore = () => {
         if (valuesTouched) {
           callValuesListenersForChanges(0);
         }
-        callListeners(
-          finishTransactionListeners[1],
-          void 0,
-          getTransactionChanges,
-          getTransactionLog,
-        );
+        postTransactionListener?.(store);
+        callListeners(finishTransactionListeners[1], void 0);
         transactions = 0;
         cellsTouched = valuesTouched = false;
         hadTables = hasTables();
@@ -3057,6 +3083,9 @@ const createStore = () => {
       collSize2(startTransactionListeners) +
       pairCollSize2(finishTransactionListeners),
   });
+  const addPostTransactionListener = (listener) => {
+    postTransactionListener = listener;
+  };
   const store = {
     getContent,
     getTables,
@@ -3097,7 +3126,7 @@ const createStore = () => {
     setValues,
     setPartialValues,
     setValue,
-    setTransactionChanges,
+    applyChanges,
     setTablesJson,
     setValuesJson,
     setJson,
@@ -3115,6 +3144,8 @@ const createStore = () => {
     delSchema,
     transaction,
     startTransaction,
+    getTransactionChanges,
+    getTransactionLog,
     finishTransaction,
     forEachTable,
     forEachTableCell,
@@ -3132,8 +3163,9 @@ const createStore = () => {
     createStore,
     addListener,
     callListeners,
+    addPostTransactionListener,
   };
-  objMap(
+  objToArray(
     {
       [HAS + TABLES]: [0, hasTablesListeners, [], () => [hasTables()]],
       [TABLES]: [0, tablesListeners],
@@ -3206,10 +3238,242 @@ const createStore = () => {
   return objFreeze(store);
 };
 
+const MASK6 = 63;
+const SHIFT36 = 2 ** 36;
+const SHIFT30 = 2 ** 30;
+const SHIFT24 = 2 ** 24;
+const SHIFT18 = 2 ** 18;
+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) +
+  toB64(logicalTime42 / SHIFT24) +
+  toB64(logicalTime42 / SHIFT18) +
+  toB64(logicalTime42 / SHIFT12) +
+  toB64(logicalTime42 / SHIFT6) +
+  toB64(logicalTime42) +
+  toB64(counter24 / SHIFT18) +
+  toB64(counter24 / SHIFT12) +
+  toB64(counter24 / SHIFT6) +
+  toB64(counter24) +
+  toB64(clientHash30 / SHIFT24) +
+  toB64(clientHash30 / SHIFT18) +
+  toB64(clientHash30 / SHIFT12) +
+  toB64(clientHash30 / SHIFT6) +
+  toB64(clientHash30);
+const decodeHlc = (hlc16) => [
+  fromB64(hlc16, 0) * SHIFT36 +
+    fromB64(hlc16, 1) * SHIFT30 +
+    fromB64(hlc16, 2) * SHIFT24 +
+    fromB64(hlc16, 3) * SHIFT18 +
+    fromB64(hlc16, 4) * SHIFT12 +
+    fromB64(hlc16, 5) * SHIFT6 +
+    fromB64(hlc16, 6),
+  fromB64(hlc16, 7) * SHIFT18 +
+    fromB64(hlc16, 8) * SHIFT12 +
+    fromB64(hlc16, 9) * SHIFT6 +
+    fromB64(hlc16, 10),
+  fromB64(hlc16, 11) * SHIFT24 +
+    fromB64(hlc16, 12) * SHIFT18 +
+    fromB64(hlc16, 13) * SHIFT12 +
+    fromB64(hlc16, 14) * SHIFT6 +
+    fromB64(hlc16, 15),
+];
+const getHlcFunctions = (uniqueId) => {
+  let logicalTime = 0;
+  let counter = 0;
+  const uniqueIdHash = hash(uniqueId);
+  const getHlc = () => {
+    seenHlc();
+    return encodeHlc(logicalTime, ++counter, 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 == previousLogicalTime
+        ? logicalTime == remoteLogicalTime
+          ? Math.max(counter, remoteCounter)
+          : counter
+        : logicalTime == remoteLogicalTime
+          ? remoteCounter
+          : -1;
+  };
+  return [getHlc, seenHlc];
+};
+
+const LISTENER_ARGS = {
+  HasTable: 1,
+  Table: 1,
+  TableCellIds: 1,
+  HasTableCell: 2,
+  RowCount: 1,
+  RowIds: 1,
+  SortedRowIds: 5,
+  HasRow: 2,
+  Row: 2,
+  CellIds: 2,
+  HasCell: 3,
+  Cell: 3,
+  HasValue: 1,
+  Value: 1,
+  InvalidCell: 3,
+  InvalidValue: 1,
+};
+const newContentStamp = () => [EMPTY_STRING, [stampNewMap(), stampNewMap()]];
+const createMergeableStore = (id) => {
+  let listening = 1;
+  let contentStamp = newContentStamp();
+  const [getHlc, seenHlc] = getHlcFunctions(id);
+  const store = createStore();
+  const disableListening = (actions) => {
+    const wasListening = listening;
+    listening = 0;
+    actions();
+    listening = wasListening;
+  };
+  const postTransactionListener = () => {
+    if (listening) {
+      const stamp = getHlc();
+      const [cellsTouched, valuesTouched, changedCells, , changedValues] =
+        store.getTransactionLog();
+      const [tablesStamp, valuesStamp] = contentStamp[1];
+      contentStamp[0] = stamp;
+      if (cellsTouched) {
+        tablesStamp[0] = stamp;
+        objToArray(changedCells, (changedTable, tableId) => {
+          const tableStamp = mapEnsure(tablesStamp[1], tableId, stampNew);
+          const rowsStamp = (tableStamp[1] ??= mapNew());
+          tableStamp[0] = stamp;
+          objToArray(changedTable, (changedRow, rowId) => {
+            const rowStamp = mapEnsure(rowsStamp, rowId, stampNew);
+            const cellsStamp = (rowStamp[1] ??= mapNew());
+            rowStamp[0] = stamp;
+            objToArray(changedRow, ([, newCell], cellId) =>
+              mapSet(cellsStamp, cellId, [stamp, newCell]),
+            );
+          });
+        });
+      }
+      if (valuesTouched) {
+        valuesStamp[0] = stamp;
+        objToArray(changedValues, ([, newValue], valueId) => {
+          mapSet(valuesStamp[1], valueId, [stamp, newValue]);
+        });
+      }
+    }
+  };
+  const merge = (mergeableStore2) => {
+    const mergeableContent = mergeableStore.getMergeableContent();
+    const mergeableContent2 = mergeableStore2.getMergeableContent();
+    mergeableStore2.applyMergeableChanges(mergeableContent);
+    return applyMergeableChanges(mergeableContent2);
+  };
+  const getMergeableContent = () =>
+    mapStamp(contentStamp, ([tablesStamp, valuesStamp]) => [
+      mapStampMapToObj(tablesStamp, (rowsStamp) =>
+        mapStampMapToObj(rowsStamp, (cellsStamp) =>
+          mapStampMapToObj(cellsStamp, pairClone),
+        ),
+      ),
+      mapStampMapToObj(valuesStamp, pairClone),
+    ]);
+  const setMergeableContent = (mergeableContent) => {
+    disableListening(() =>
+      store.transaction(() => {
+        store.delTables().delValues();
+        contentStamp = newContentStamp();
+      }),
+    );
+    applyMergeableChanges(mergeableContent);
+    return mergeableStore;
+  };
+  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);
+      },
+    );
+    disableListening(() => store.applyChanges(changes));
+    return mergeableStore;
+  };
+  const mergeableStore = {
+    getMergeableContent,
+    setMergeableContent,
+    applyMergeableChanges,
+    merge,
+  };
+  store.addPostTransactionListener(postTransactionListener);
+  objToArray(
+    store,
+    (method, name) =>
+      (mergeableStore[name] = // fluent methods
+        strStartsWith(name, 'set') ||
+        strStartsWith(name, 'del') ||
+        strStartsWith(name, 'apply') ||
+        strEndsWith(name, 'Transaction') ||
+        name == 'callListener'
+          ? (...args) => {
+              method(...args);
+              return mergeableStore;
+            }
+          : strStartsWith(name, 'add') && strEndsWith(name, 'Listener')
+            ? (...args) => {
+                const listenerArg = LISTENER_ARGS[slice(name, 3, -8)] ?? 0;
+                const listener = args[listenerArg];
+                args[listenerArg] = (_store, ...args2) =>
+                  listener(mergeableStore, ...args2);
+                return method(...args);
+              }
+            : method),
+  );
+  return objFreeze(mergeableStore);
+};
+
 export {
   createCheckpoints,
   createCustomPersister,
   createIndexes,
+  createMergeableStore,
   createMetrics,
   createQueries,
   createRelationships,