tinybase 4.0.0-beta.1 → 4.0.0-beta.2

package/lib/debug/relationships.js

@@ -20,6 +20,9 @@ const isString = (thing) => getTypeOf(thing) == STRING;
 const isArray = (thing) => Array.isArray(thing);
 const test = (regex, subject) => regex.test(subject);
 
+const object = Object;
+const objFreeze = object.freeze;
+
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
 const collSize = (coll) => coll.size;
@@ -317,9 +320,6 @@ const getListenerFunctions = (getThing) => {
   return [addListener, callListeners, delListener, callListener];
 };
 
-const object = Object;
-const objFreeze = object.freeze;
-
 const createRelationships = getCreateFunction((store) => {
   const remoteTableIds = mapNew();
   const remoteRowIdListeners = mapNew();

package/lib/debug/store.js

@@ -32,7 +32,6 @@ const arrayMap = (array, cb) => array.map(cb);
 const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
-const arrayFilter = (array, cb) => array.filter(cb);
 const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
@@ -61,6 +60,19 @@ const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
 const isArray = (thing) => Array.isArray(thing);
 const test = (regex, subject) => regex.test(subject);
 
+const object = Object;
+const objIds = object.keys;
+const objFrozen = object.isFrozen;
+const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objDel = (obj, id) => delete obj[id];
+const objMap = (obj, cb) =>
+  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
+const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
+
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
 const collSize = (coll) => coll.size;
@@ -89,23 +101,33 @@ const mapEnsure = (map, key, getDefaultValue) => {
   }
   return mapGet(map, key);
 };
-const mapToObj = (map, childMapper, childExclude) => {
+const mapToObj = (map, mapValue, excludeValue) => {
   const obj = {};
-  const mapper = childMapper ?? ((mapValue) => mapValue);
-  collForEach(map, (value, key) =>
-    ifNotUndefined(mapper(value), (mappedValue) =>
-      childExclude?.(mappedValue) ? 0 : (obj[key] = mappedValue),
-    ),
-  );
+  collForEach(map, (value, id) => {
+    const mappedValue = mapValue ? mapValue(value, id) : value;
+    excludeValue?.(mappedValue, value) ? 0 : (obj[id] = mappedValue);
+  });
   return obj;
 };
-const mapClone = (map, childMapper) => {
+const mapToObj2 = (map, mapValue, excludeValue) =>
+  mapToObj(
+    map,
+    (childMap) => mapToObj(childMap, mapValue, excludeValue),
+    objIsEmpty,
+  );
+const mapToObj3 = (map, mapValue, excludeValue) =>
+  mapToObj(
+    map,
+    (childMap) => mapToObj2(childMap, mapValue, excludeValue),
+    objIsEmpty,
+  );
+const mapClone = (map, mapValue) => {
   const map2 = mapNew();
-  const mapper = childMapper ?? ((mapValue) => mapValue);
-  collForEach(map, (value, key) => map2.set(key, mapper(value)));
+  collForEach(map, (value, key) => map2.set(key, mapValue?.(value) ?? value));
   return map2;
 };
 const mapClone2 = (map) => mapClone(map, mapClone);
+const mapClone3 = (map) => mapClone(map, mapClone2);
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(
     (ensureLeaf ? mapEnsure : mapGet)(
@@ -220,22 +242,11 @@ const getListenerFunctions = (getThing) => {
   return [addListener, callListeners, delListener, callListener];
 };
 
-const object = Object;
-const objIds = object.keys;
-const objFrozen = object.isFrozen;
-const objFreeze = object.freeze;
-const isObject = (obj) =>
-  isInstanceOf(obj, object) && obj.constructor == object;
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
-const objDel = (obj, id) => delete obj[id];
-const objMap = (obj, cb) =>
-  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
-
 const pairNew = (value) => [value, value];
 const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
 const pairNewMap = () => [mapNew(), mapNew()];
+const pairClone = (array) => [...array];
+const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
 
 const getCellOrValueType = (cell) => {
   const type = getTypeOf(cell);
@@ -252,15 +263,9 @@ const setOrDelValue = (store, valueId, value) =>
 
 const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
 
-const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
-  const idsToDelete = arrayFilter(
-    mapKeys(map),
-    (id2) => !objHas(toBeLikeObject, id2),
-  );
-  arrayForEach(objIds(toBeLikeObject), (id2) =>
-    setId(map, id2, toBeLikeObject[id2]),
-  );
-  arrayForEach(idsToDelete, (id2) => delId(map, id2));
+const mapMatch = (map, obj, set, del = mapSet) => {
+  objMap(obj, (value, id2) => set(map, id2, value));
+  mapForEach(map, (id2) => (objHas(obj, id2) ? 0 : del(map, id2)));
   return map;
 };
 const validate = (obj, validateChild, onInvalidObj) => {
@@ -275,8 +280,12 @@ const validate = (obj, validateChild, onInvalidObj) => {
   });
   return !objIsEmpty(obj);
 };
-const idsChanged = (changedIds, id2, added) =>
-  mapSet(changedIds, id2, mapGet(changedIds, id2) == -added ? void 0 : added);
+const idsChanged = (changedIds, id2, addedOrRemoved) =>
+  mapSet(
+    changedIds,
+    id2,
+    mapGet(changedIds, id2) == -addedOrRemoved ? void 0 : addedOrRemoved,
+  );
 const createStore = () => {
   let hasTablesSchema;
   let hasValuesSchema;
@@ -433,13 +442,13 @@ const createStore = () => {
     return values;
   };
   const setValidTablesSchema = (tablesSchema) =>
-    transformMap(
+    mapMatch(
       tablesSchemaMap,
       tablesSchema,
       (_tablesSchema, tableId, tableSchema) => {
         const rowDefaulted = mapNew();
         const rowNonDefaulted = setNew();
-        transformMap(
+        mapMatch(
           mapEnsure(tablesSchemaMap, tableId, mapNew),
           tableSchema,
           (tableSchemaMap, cellId, cellSchema) => {
@@ -459,7 +468,7 @@ const createStore = () => {
       },
     );
   const setValidValuesSchema = (valuesSchema) =>
-    transformMap(
+    mapMatch(
       valuesSchemaMap,
       valuesSchema,
       (_valuesSchema, valueId, valueSchema) => {
@@ -479,14 +488,14 @@ const createStore = () => {
   const setOrDelTables = (tables) =>
     objIsEmpty(tables) ? delTables() : setTables(tables);
   const setValidTables = (tables) =>
-    transformMap(
+    mapMatch(
       tablesMap,
       tables,
       (_tables, tableId, table) => setValidTable(tableId, table),
       (_tables, tableId) => delValidTable(tableId),
     );
   const setValidTable = (tableId, table) =>
-    transformMap(
+    mapMatch(
       mapEnsure(tablesMap, tableId, () => {
         tableIdsChanged(tableId, 1);
         return mapNew();
@@ -496,7 +505,7 @@ const createStore = () => {
       (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
     );
   const setValidRow = (tableId, tableMap, rowId, row, forceDel) =>
-    transformMap(
+    mapMatch(
       mapEnsure(tableMap, rowId, () => {
         rowIdsChanged(tableId, rowId, 1);
         return mapNew();
@@ -532,7 +541,7 @@ const createStore = () => {
   const setOrDelValues = (values) =>
     objIsEmpty(values) ? delValues() : setValues(values);
   const setValidValues = (values) =>
-    transformMap(
+    mapMatch(
       valuesMap,
       values,
       (_valuesMap, valueId, value) => setValidValue(valueId, value),
@@ -600,15 +609,19 @@ const createStore = () => {
     valueIdsChanged(valueId, -1);
     mapSet(valuesMap, valueId);
   };
-  const tableIdsChanged = (tableId, added) =>
-    idsChanged(changedTableIds, tableId, added);
-  const rowIdsChanged = (tableId, rowId, added) =>
-    idsChanged(mapEnsure(changedRowIds, tableId, mapNew), rowId, added);
-  const cellIdsChanged = (tableId, rowId, cellId, added) =>
+  const tableIdsChanged = (tableId, addedOrRemoved) =>
+    idsChanged(changedTableIds, tableId, addedOrRemoved);
+  const rowIdsChanged = (tableId, rowId, addedOrRemoved) =>
+    idsChanged(
+      mapEnsure(changedRowIds, tableId, mapNew),
+      rowId,
+      addedOrRemoved,
+    );
+  const cellIdsChanged = (tableId, rowId, cellId, addedOrRemoved) =>
     idsChanged(
       mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),
       cellId,
-      added,
+      addedOrRemoved,
     );
   const cellChanged = (tableId, rowId, cellId, oldCell, newCell) =>
     (mapEnsure(
@@ -616,8 +629,8 @@ const createStore = () => {
       cellId,
       () => [oldCell, 0],
     )[1] = newCell);
-  const valueIdsChanged = (valueId, added) =>
-    idsChanged(changedValueIds, valueId, added);
+  const valueIdsChanged = (valueId, addedOrRemoved) =>
+    idsChanged(changedValueIds, valueId, addedOrRemoved);
   const valueChanged = (valueId, oldValue, newValue) =>
     (mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue);
   const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
@@ -653,7 +666,7 @@ const createStore = () => {
   const callInvalidCellListeners = (mutator) =>
     !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])
       ? collForEach(
-          mutator ? mapClone(invalidCells, mapClone2) : invalidCells,
+          mutator ? mapClone3(invalidCells) : invalidCells,
           (rows, tableId) =>
             collForEach(rows, (cells, rowId) =>
               collForEach(cells, (invalidCell, cellId) =>
@@ -703,8 +716,8 @@ const createStore = () => {
         ? [
             mapClone(changedTableIds),
             mapClone2(changedRowIds),
-            mapClone(changedCellIds, mapClone2),
-            mapClone(changedCells, mapClone2),
+            mapClone3(changedCellIds),
+            mapClone3(changedCells),
           ]
         : [changedTableIds, changedRowIds, changedCellIds, changedCells];
       if (!emptyIdListeners) {
@@ -822,12 +835,48 @@ 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 = () =>
-    mapToObj(tablesMap, (table) => mapToObj(table, mapToObj));
+  const getTables = () => mapToObj3(tablesMap);
   const getTableIds = () => mapKeys(tablesMap);
-  const getTable = (tableId) =>
-    mapToObj(mapGet(tablesMap, id(tableId)), mapToObj);
+  const getTable = (tableId) => mapToObj2(mapGet(tablesMap, id(tableId)));
   const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, id(tableId)));
   const getSortedRowIds = (tableId, cellId, descending, offset = 0, limit) =>
     arrayMap(
@@ -966,6 +1015,23 @@ const createStore = () => {
         ),
       valueId,
     );
+  const setTransactionChanges = (transactionChanges) =>
+    fluentTransaction(() => {
+      objMap(transactionChanges[0], (table, tableId) =>
+        isUndefined(table)
+          ? delTable(tableId)
+          : objMap(table, (row, rowId) =>
+              isUndefined(row)
+                ? delRow(tableId, rowId)
+                : objMap(row, (cell, cellId) =>
+                    setOrDelCell(store, tableId, rowId, cellId, cell),
+                  ),
+            ),
+      );
+      objMap(transactionChanges[1], (value, valueId) =>
+        setOrDelValue(store, valueId, value),
+      );
+    });
   const setTablesJson = (tablesJson) => {
     try {
       setOrDelTables(jsonParse(tablesJson));
@@ -1105,36 +1171,7 @@ const createStore = () => {
           callKeyedValuesListenersForChanges(1);
         }
         transactions = -1;
-        let transactionChanges =
-          doRollback ||
-          !collIsEmpty(finishTransactionListeners[0]) ||
-          !collIsEmpty(finishTransactionListeners[1])
-            ? [
-                mapToObj(
-                  changedCells,
-                  (table) =>
-                    mapToObj(
-                      table,
-                      (row) =>
-                        mapToObj(
-                          row,
-                          (cells) => [...cells],
-                          ([oldCell, newCell]) => oldCell === newCell,
-                        ),
-                      objIsEmpty,
-                    ),
-                  objIsEmpty,
-                ),
-                mapToObj(invalidCells, (map) => mapToObj(map, mapToObj)),
-                mapToObj(
-                  changedValues,
-                  (values) => [...values],
-                  ([oldValue, newValue]) => oldValue === newValue,
-                ),
-                mapToObj(invalidValues),
-              ]
-            : [{}, {}, {}, {}];
-        if (doRollback?.(...transactionChanges)) {
+        if (doRollback?.(getTransactionChanges, getTransactionLog)) {
           transactions = 1;
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
@@ -1148,14 +1185,12 @@ const createStore = () => {
           );
           transactions = -1;
           cellsTouched = valuesTouched = false;
-          transactionChanges = [{}, {}, {}, {}];
         }
         callListeners(
           finishTransactionListeners[0],
           void 0,
-          cellsTouched,
-          valuesTouched,
-          ...transactionChanges,
+          getTransactionChanges,
+          getTransactionLog,
         );
         callInvalidCellListeners(0);
         if (cellsTouched) {
@@ -1168,9 +1203,8 @@ const createStore = () => {
         callListeners(
           finishTransactionListeners[1],
           void 0,
-          cellsTouched,
-          valuesTouched,
-          ...transactionChanges,
+          getTransactionChanges,
+          getTransactionLog,
         );
         transactions = 0;
         arrayForEach(
@@ -1313,6 +1347,7 @@ const createStore = () => {
     setValues,
     setPartialValues,
     setValue,
+    setTransactionChanges,
     setTablesJson,
     setValuesJson,
     setJson,