tinybase 7.3.3 → 7.3.4

package/checkpoints/index.js

@@ -39,19 +39,20 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 const object = Object;
 const objFreeze = object.freeze;
 
-const mapNew = (entries) => new Map(entries);
-const mapGet = (map, key) => map?.get(key);
-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, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapGet = (map2, key) => map2?.get(key);
+const mapForEach = (map2, cb) =>
+  collForEach(map2, (value, key) => cb(key, value));
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map2, key)) {
+    mapSet(map2, key, getDefaultValue());
   } else {
-    hadExistingValue?.(mapGet(map, key));
+    hadExistingValue?.(mapGet(map2, key));
   }
-  return mapGet(map, key);
+  return mapGet(map2, key);
 };
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(

package/checkpoints/with-schemas/index.js

@@ -39,19 +39,20 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 const object = Object;
 const objFreeze = object.freeze;
 
-const mapNew = (entries) => new Map(entries);
-const mapGet = (map, key) => map?.get(key);
-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, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapGet = (map2, key) => map2?.get(key);
+const mapForEach = (map2, cb) =>
+  collForEach(map2, (value, key) => cb(key, value));
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map2, key)) {
+    mapSet(map2, key, getDefaultValue());
   } else {
-    hadExistingValue?.(mapGet(map, key));
+    hadExistingValue?.(mapGet(map2, key));
   }
-  return mapGet(map, key);
+  return mapGet(map2, key);
 };
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(

package/common/index.js

@@ -19,8 +19,9 @@ const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const object = Object;
 const objEntries = object.entries;
 
-const mapNew = (entries) => new Map(entries);
-const mapGet = (map, key) => map?.get(key);
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapGet = (map2, key) => map2?.get(key);
 
 const MASK6 = 63;
 const ENCODE = /* @__PURE__ */ strSplit(

package/common/with-schemas/index.js

@@ -19,8 +19,9 @@ const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const object = Object;
 const objEntries = object.entries;
 
-const mapNew = (entries) => new Map(entries);
-const mapGet = (map, key) => map?.get(key);
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapGet = (map2, key) => map2?.get(key);
 
 const MASK6 = 63;
 const ENCODE = /* @__PURE__ */ strSplit(

package/index.js

@@ -208,31 +208,32 @@ const objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
   return emptyIsValid ? true : !objIsEmpty(obj);
 };
 
-const mapNew = (entries) => new Map(entries);
-const mapKeys = (map) => [...(map?.keys() ?? [])];
-const mapGet = (map, key) => map?.get(key);
-const mapForEach = (map, cb) =>
-  collForEach(map, (value, key) => cb(key, value));
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapKeys = (map2) => [...(map2?.keys() ?? [])];
+const mapGet = (map2, key) => map2?.get(key);
+const mapForEach = (map2, cb) =>
+  collForEach(map2, (value, key) => cb(key, value));
 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, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map2, key)) {
+    mapSet(map2, key, getDefaultValue());
   } else {
-    hadExistingValue?.(mapGet(map, key));
+    hadExistingValue?.(mapGet(map2, key));
   }
-  return mapGet(map, key);
+  return mapGet(map2, key);
 };
-const mapMatch = (map, obj, set, del = mapSet) => {
-  objMap(obj, (value, id) => set(map, id, value));
-  mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
-  return map;
+const mapMatch = (map2, obj, set, del = mapSet) => {
+  objMap(obj, (value, id) => set(map2, id, value));
+  mapForEach(map2, (id) => (objHas(obj, id) ? 0 : del(map2, id)));
+  return map2;
 };
-const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
+const mapToObj = (map2, valueMapper, excludeMapValue, excludeObjValue) => {
   const obj = {};
-  collForEach(map, (mapValue, id) => {
+  collForEach(map2, (mapValue, id) => {
     if (!excludeMapValue?.(mapValue, id)) {
       const objValue = valueMapper ? valueMapper(mapValue, id) : mapValue;
       if (!excludeObjValue?.(objValue)) {
@@ -242,27 +243,27 @@ const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
   });
   return obj;
 };
-const mapToObj2 = (map, valueMapper, excludeMapValue) =>
+const mapToObj2 = (map2, valueMapper, excludeMapValue) =>
   mapToObj(
-    map,
+    map2,
     (childMap) => mapToObj(childMap, valueMapper, excludeMapValue),
     collIsEmpty,
     objIsEmpty,
   );
-const mapToObj3 = (map, valueMapper, excludeMapValue) =>
+const mapToObj3 = (map2, valueMapper, excludeMapValue) =>
   mapToObj(
-    map,
+    map2,
     (childMap) => mapToObj2(childMap, valueMapper, excludeMapValue),
     collIsEmpty,
     objIsEmpty,
   );
-const mapClone = (map, mapValue) => {
-  const map2 = mapNew();
-  collForEach(map, (value, key) => map2.set(key, mapValue?.(value) ?? value));
-  return map2;
+const mapClone = (map2, mapValue) => {
+  const map22 = mapNew();
+  collForEach(map2, (value, key) => map22.set(key, mapValue?.(value) ?? value));
+  return map22;
 };
-const mapClone2 = (map) => mapClone(map, mapClone);
-const mapClone3 = (map) => mapClone(map, mapClone2);
+const mapClone2 = (map2) => mapClone(map2, mapClone);
+const mapClone3 = (map2) => mapClone(map2, mapClone2);
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(
     (ensureLeaf ? mapEnsure : mapGet)(
@@ -1218,6 +1219,7 @@ const createStore = () => {
   let hadValues = false;
   let transactions = 0;
   let internalListeners = [];
+  let mutating = 0;
   const changedTableIds = mapNew();
   const changedTableCellIds = mapNew();
   const changedRowCount = mapNew();
@@ -1622,13 +1624,13 @@ const createStore = () => {
       cellId,
       () => [oldCell, 0],
     )[1] = newCell;
-    internalListeners[3]?.(tableId, rowId, cellId, newCell);
+    internalListeners[3]?.(tableId, rowId, cellId, newCell, mutating);
   };
   const valueIdsChanged = (valueId, addedOrRemoved) =>
     idsChanged(changedValueIds, valueId, addedOrRemoved);
   const valueChanged = (valueId, oldValue, newValue) => {
     mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue;
-    internalListeners[4]?.(valueId, newValue);
+    internalListeners[4]?.(valueId, newValue, mutating);
   };
   const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
     arrayPush(
@@ -1703,14 +1705,11 @@ const createStore = () => {
     }
   };
   const callTabularListenersForChanges = (mutator) => {
-    const hasTablesNow = hasTables();
-    if (hasTablesNow != hadTables) {
-      callListeners(hasTablesListeners[mutator], void 0, hasTablesNow);
-    }
-    const emptySortedRowIdListeners = collIsEmpty(
+    const hasHasTablesListeners = !collIsEmpty(hasTablesListeners[mutator]);
+    const hasSortedRowIdListeners = !collIsEmpty(
       sortedRowIdsListeners[mutator],
     );
-    const emptyIdAndHasListeners =
+    const hasIdOrHasListeners = !(
       collIsEmpty(cellIdsListeners[mutator]) &&
       collIsEmpty(hasCellListeners[mutator]) &&
       collIsEmpty(rowIdsListeners[mutator]) &&
@@ -1718,15 +1717,17 @@ const createStore = () => {
       collIsEmpty(tableCellIdsListeners[mutator]) &&
       collIsEmpty(hasTableCellListeners[mutator]) &&
       collIsEmpty(rowCountListeners[mutator]) &&
-      emptySortedRowIdListeners &&
+      !hasSortedRowIdListeners &&
       collIsEmpty(tableIdsListeners[mutator]) &&
-      collIsEmpty(hasTableListeners[mutator]);
-    const emptyOtherListeners =
+      collIsEmpty(hasTableListeners[mutator])
+    );
+    const hasOtherListeners = !(
       collIsEmpty(cellListeners[mutator]) &&
       collIsEmpty(rowListeners[mutator]) &&
       collIsEmpty(tableListeners[mutator]) &&
-      collIsEmpty(tablesListeners[mutator]);
-    if (!emptyIdAndHasListeners || !emptyOtherListeners) {
+      collIsEmpty(tablesListeners[mutator])
+    );
+    if (hasHasTablesListeners || hasIdOrHasListeners || hasOtherListeners) {
       const changes = mutator
         ? [
             mapClone(changedTableIds),
@@ -1734,7 +1735,9 @@ const createStore = () => {
             mapClone(changedRowCount),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
-            mapClone3(changedCells),
+            mapClone(changedCells, (map) =>
+              mapClone(map, (map2) => mapClone(map2, pairClone)),
+            ),
           ]
         : [
             changedTableIds,
@@ -1744,7 +1747,13 @@ const createStore = () => {
             changedCellIds,
             changedCells,
           ];
-      if (!emptyIdAndHasListeners) {
+      if (hasHasTablesListeners) {
+        const hasTablesNow = hasTables();
+        if (hasTablesNow != hadTables) {
+          callListeners(hasTablesListeners[mutator], void 0, hasTablesNow);
+        }
+      }
+      if (hasIdOrHasListeners) {
         callIdsAndHasListenersIfChanged(
           changes[0],
           tableIdsListeners[mutator],
@@ -1776,13 +1785,13 @@ const createStore = () => {
               hasRowListeners[mutator],
               [tableId],
             ) &&
-            !emptySortedRowIdListeners
+            hasSortedRowIdListeners
           ) {
             callListeners(sortedRowIdsListeners[mutator], [tableId, null]);
             setAdd(calledSortableTableIds, tableId);
           }
         });
-        if (!emptySortedRowIdListeners) {
+        if (hasSortedRowIdListeners) {
           collForEach(changes[5], (rows, tableId) => {
             if (!collHas(calledSortableTableIds, tableId)) {
               const sortableCellIds = setNew();
@@ -1813,7 +1822,7 @@ const createStore = () => {
           ),
         );
       }
-      if (!emptyOtherListeners) {
+      if (hasOtherListeners) {
         let tablesChanged;
         collForEach(changes[5], (rows, tableId) => {
           let tableChanged;
@@ -1850,28 +1859,31 @@ const createStore = () => {
     }
   };
   const callValuesListenersForChanges = (mutator) => {
-    const hasValuesNow = hasValues();
-    if (hasValuesNow != hadValues) {
-      callListeners(hasValuesListeners[mutator], void 0, hasValuesNow);
-    }
-    const emptyIdAndHasListeners =
-      collIsEmpty(valueIdsListeners[mutator]) &&
-      collIsEmpty(hasValueListeners[mutator]);
-    const emptyOtherListeners =
-      collIsEmpty(valueListeners[mutator]) &&
-      collIsEmpty(valuesListeners[mutator]);
-    if (!emptyIdAndHasListeners || !emptyOtherListeners) {
+    const hasHasValuesListeners = !collIsEmpty(hasValuesListeners[mutator]);
+    const hasIdOrHasListeners =
+      !collIsEmpty(valueIdsListeners[mutator]) ||
+      !collIsEmpty(hasValueListeners[mutator]);
+    const hasOtherListeners =
+      !collIsEmpty(valueListeners[mutator]) ||
+      !collIsEmpty(valuesListeners[mutator]);
+    if (hasHasValuesListeners || hasIdOrHasListeners || hasOtherListeners) {
       const changes = mutator
-        ? [mapClone(changedValueIds), mapClone(changedValues)]
+        ? [mapClone(changedValueIds), mapClone(changedValues, pairClone)]
         : [changedValueIds, changedValues];
-      if (!emptyIdAndHasListeners) {
+      if (hasHasValuesListeners) {
+        const hasValuesNow = hasValues();
+        if (hasValuesNow != hadValues) {
+          callListeners(hasValuesListeners[mutator], void 0, hasValuesNow);
+        }
+      }
+      if (hasIdOrHasListeners) {
         callIdsAndHasListenersIfChanged(
           changes[0],
           valueIdsListeners[mutator],
           hasValueListeners[mutator],
         );
       }
-      if (!emptyOtherListeners) {
+      if (hasOtherListeners) {
         let valuesChanged;
         collForEach(changes[1], ([oldValue, newValue], valueId) => {
           if (newValue !== oldValue) {
@@ -2268,6 +2280,7 @@ const createStore = () => {
       transactions--;
       if (transactions == 0) {
         transactions = 1;
+        mutating = 1;
         callInvalidCellListeners(1);
         if (!collIsEmpty(changedCells)) {
           callTabularListenersForChanges(1);
@@ -2276,6 +2289,7 @@ const createStore = () => {
         if (!collIsEmpty(changedValues)) {
           callValuesListenersForChanges(1);
         }
+        mutating = 0;
         if (doRollback?.(store)) {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
@@ -2642,6 +2656,7 @@ const createMergeableStore = (uniqueId, getNow) => {
   let listeningToRawStoreChanges = 1;
   let contentStampMap = newContentStampMap();
   let defaultingContent = 0;
+  let mutated = 0;
   const touchedCells = mapNew();
   const touchedValues = setNew();
   const [getNextHlc, seenHlc] = getHlcFunctions(uniqueId, getNow);
@@ -2768,12 +2783,15 @@ const createMergeableStore = (uniqueId, getNow) => {
     collClear(touchedCells);
     collClear(touchedValues);
   };
-  const cellChanged = (tableId, rowId, cellId, newCell) => {
+  const cellChanged = (tableId, rowId, cellId, newCell, mutating) => {
     setAdd(
       mapEnsure(mapEnsure(touchedCells, tableId, mapNew), rowId, setNew),
       cellId,
     );
-    if (listeningToRawStoreChanges) {
+    if (listeningToRawStoreChanges || mutating) {
+      if (mutating) {
+        mutated = 1;
+      }
       mergeContentOrChanges([
         [
           {
@@ -2796,9 +2814,12 @@ const createMergeableStore = (uniqueId, getNow) => {
       ]);
     }
   };
-  const valueChanged = (valueId, newValue) => {
+  const valueChanged = (valueId, newValue, mutating) => {
     setAdd(touchedValues, valueId);
-    if (listeningToRawStoreChanges) {
+    if (listeningToRawStoreChanges || mutating) {
+      if (mutating) {
+        mutated = 1;
+      }
       mergeContentOrChanges([
         [{}],
         [
@@ -3016,6 +3037,11 @@ const createMergeableStore = (uniqueId, getNow) => {
     mergeableStore2.applyMergeableChanges(mergeableChanges);
     return applyMergeableChanges(mergeableChanges2);
   };
+  const hadMutated = () => {
+    const result = mutated;
+    mutated = 0;
+    return result;
+  };
   const mergeableStore = {
     getMergeableContent,
     getMergeableContentHashes,
@@ -3032,6 +3058,8 @@ const createMergeableStore = (uniqueId, getNow) => {
     getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
+    // only used internally by other modules
+    hadMutated,
   };
   store.setInternalListeners(
     preStartTransaction,

package/indexes/index.js

@@ -45,20 +45,21 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 const object = Object;
 const objFreeze = object.freeze;
 
-const mapNew = (entries) => new Map(entries);
-const mapKeys = (map) => [...(map?.keys() ?? [])];
-const mapGet = (map, key) => map?.get(key);
-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, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapKeys = (map2) => [...(map2?.keys() ?? [])];
+const mapGet = (map2, key) => map2?.get(key);
+const mapForEach = (map2, cb) =>
+  collForEach(map2, (value, key) => cb(key, value));
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map2, key)) {
+    mapSet(map2, key, getDefaultValue());
   } else {
-    hadExistingValue?.(mapGet(map, key));
+    hadExistingValue?.(mapGet(map2, key));
   }
-  return mapGet(map, key);
+  return mapGet(map2, key);
 };
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(

package/indexes/with-schemas/index.js

@@ -45,20 +45,21 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 const object = Object;
 const objFreeze = object.freeze;
 
-const mapNew = (entries) => new Map(entries);
-const mapKeys = (map) => [...(map?.keys() ?? [])];
-const mapGet = (map, key) => map?.get(key);
-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, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapKeys = (map2) => [...(map2?.keys() ?? [])];
+const mapGet = (map2, key) => map2?.get(key);
+const mapForEach = (map2, cb) =>
+  collForEach(map2, (value, key) => cb(key, value));
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map2, key)) {
+    mapSet(map2, key, getDefaultValue());
   } else {
-    hadExistingValue?.(mapGet(map, key));
+    hadExistingValue?.(mapGet(map2, key));
   }
-  return mapGet(map, key);
+  return mapGet(map2, key);
 };
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(