tinybase 7.3.5 → 8.0.0-beta.1

package/mergeable-store/with-schemas/index.js

@@ -53,6 +53,7 @@ const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
 const size = (arrayOrString) => arrayOrString.length;
 const test = (regex, subject) => regex.test(subject);
 const noop = () => {};
+const structuredClone = GLOBAL.structuredClone;
 const tryCatch = async (action, then1, then2) => {
   try {
     return await action();
@@ -74,12 +75,6 @@ const getCellOrValueType = (cellOrValue) => {
 };
 const isCellOrValueOrUndefined = (cellOrValue) =>
   isUndefined(cellOrValue) || !isUndefined(getCellOrValueType(cellOrValue));
-const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
-  isUndefined(cell)
-    ? store.delCell(tableId, rowId, cellId, true)
-    : store.setCell(tableId, rowId, cellId, cell);
-const setOrDelValue = (store, valueId, value) =>
-  isUndefined(value) ? store.delValue(valueId) : store.setValue(valueId, value);
 
 const arrayHas = (array, value) => array.includes(value);
 const arrayEvery = (array, cb) => array.every(cb);
@@ -137,6 +132,26 @@ const objMap = (obj, cb) =>
   objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+/* istanbul ignore next */
+const objIsEqual = (
+  obj1,
+  obj2,
+  isEqual = (value1, value2) => value1 === value2,
+) => {
+  const entries1 = objEntries(obj1);
+  return (
+    size(entries1) === objSize(obj2) &&
+    arrayEvery(entries1, ([index, value1]) =>
+      isObject(value1)
+        ? /* istanbul ignore next */
+          isObject(obj2[index])
+          ? objIsEqual(obj2[index], value1)
+          : false
+        : isEqual(value1, obj2[index]),
+    )
+  );
+};
 const objEnsure = (obj, id, getDefaultValue) => {
   if (!objHas(obj, id)) {
     obj[id] = getDefaultValue();
@@ -504,12 +519,15 @@ const idsChanged = (changedIds, id2, addedOrRemoved) =>
     id2,
     mapGet(changedIds, id2) == -addedOrRemoved ? void 0 : addedOrRemoved,
   );
+const contentOrChangesIsEqual = ([tables1, values1], [tables2, values2]) =>
+  objIsEqual(tables1, tables2) && objIsEqual(values1, values2);
 const createStore = () => {
   let hasTablesSchema;
   let hasValuesSchema;
   let hadTables = false;
   let hadValues = false;
   let transactions = 0;
+  let middleware = [];
   let internalListeners = [];
   let mutating = 0;
   const changedTableIds = mapNew();
@@ -557,6 +575,19 @@ const createStore = () => {
   const finishTransactionListeners = pairNewMap();
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
+  const whileMutating = (action) => {
+    const wasMutating = mutating;
+    mutating = 1;
+    const result = action();
+    mutating = wasMutating;
+    return result;
+  };
+  const ifTransformed = (snapshot, getResult, then, isEqual = Object.is) =>
+    ifNotUndefined(getResult(), (result) =>
+      snapshot === result || isEqual(snapshot, result)
+        ? then(result)
+        : whileMutating(() => then(result)),
+    );
   const validateTablesSchema = (tableSchema) =>
     objValidate(tableSchema, (tableSchema2) =>
       objValidate(tableSchema2, validateCellOrValueSchema),
@@ -744,82 +775,194 @@ const createStore = () => {
     );
   const setOrDelTables = (tables) =>
     objIsEmpty(tables) ? delTables() : setTables(tables);
-  const setValidContent = ([tables, values]) => {
-    (objIsEmpty(tables) ? delTables : setTables)(tables);
-    (objIsEmpty(values) ? delValues : setValues)(values);
-  };
-  const setValidTables = (tables) =>
-    mapMatch(
-      tablesMap,
+  const setOrDelCell = (tableId, rowId, cellId, cell, skipMiddleware) =>
+    isUndefined(cell)
+      ? delCell(tableId, rowId, cellId, true, skipMiddleware)
+      : setCell(tableId, rowId, cellId, cell, skipMiddleware);
+  const setOrDelValues = (values) =>
+    objIsEmpty(values) ? delValues() : setValues(values);
+  const setOrDelValue = (valueId, value, skipMiddleware) =>
+    isUndefined(value)
+      ? delValue(valueId, skipMiddleware)
+      : setValue(valueId, value, skipMiddleware);
+  const setValidContent = (content) =>
+    ifTransformed(
+      content,
+      () =>
+        ifNotUndefined(
+          middleware[0],
+          (willSetContent) =>
+            whileMutating(() => willSetContent(structuredClone(content))),
+          () => content,
+        ),
+      ([tables, values]) => {
+        (objIsEmpty(tables) ? delTables : setTables)(tables);
+        (objIsEmpty(values) ? delValues : setValues)(values);
+      },
+      contentOrChangesIsEqual,
+    );
+  const setValidTables = (tables, forceDel) =>
+    ifTransformed(
       tables,
-      (_tables, tableId, table) => setValidTable(tableId, table),
-      (_tables, tableId) => delValidTable(tableId),
+      () =>
+        forceDel
+          ? tables
+          : ifNotUndefined(
+              middleware[1],
+              (willSetTables) =>
+                whileMutating(() => willSetTables(structuredClone(tables))),
+              () => tables,
+            ),
+      (validTables) =>
+        mapMatch(
+          tablesMap,
+          validTables,
+          (_tables, tableId, table) => setValidTable(tableId, table),
+          (_tables, tableId) => delValidTable(tableId),
+        ),
+      objIsEqual,
     );
-  const setValidTable = (tableId, table) =>
-    mapMatch(
-      mapEnsure(tablesMap, tableId, () => {
-        tableIdsChanged(tableId, 1);
-        mapSet(tablePoolFunctions, tableId, getPoolFunctions());
-        mapSet(tableCellIds, tableId, mapNew());
-        return mapNew();
-      }),
+  const setValidTable = (tableId, table, forceDel) =>
+    ifTransformed(
       table,
-      (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),
-      (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
+      () =>
+        forceDel
+          ? table
+          : ifNotUndefined(
+              middleware[2],
+              (willSetTable) =>
+                whileMutating(() =>
+                  willSetTable(tableId, structuredClone(table)),
+                ),
+              () => table,
+            ),
+      (validTable) =>
+        mapMatch(
+          mapEnsure(tablesMap, tableId, () => {
+            tableIdsChanged(tableId, 1);
+            mapSet(tablePoolFunctions, tableId, getPoolFunctions());
+            mapSet(tableCellIds, tableId, mapNew());
+            return mapNew();
+          }),
+          validTable,
+          (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),
+          (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
+        ),
+      objIsEqual,
     );
   const setValidRow = (tableId, tableMap, rowId, row, forceDel) =>
-    mapMatch(
-      mapEnsure(tableMap, rowId, () => {
-        rowIdsChanged(tableId, rowId, 1);
-        return mapNew();
-      }),
+    ifTransformed(
       row,
-      (rowMap, cellId, cell) =>
-        setValidCell(tableId, rowId, rowMap, cellId, cell),
-      (rowMap, cellId) =>
-        delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
+      () =>
+        forceDel
+          ? row
+          : ifNotUndefined(
+              middleware[3],
+              (willSetRow) =>
+                whileMutating(() =>
+                  willSetRow(tableId, rowId, structuredClone(row)),
+                ),
+              () => row,
+            ),
+      (validRow) =>
+        mapMatch(
+          mapEnsure(tableMap, rowId, () => {
+            rowIdsChanged(tableId, rowId, 1);
+            return mapNew();
+          }),
+          validRow,
+          (rowMap, cellId, cell) =>
+            setValidCell(tableId, rowId, rowMap, cellId, cell),
+          (rowMap, cellId) =>
+            delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
+        ),
+      objIsEqual,
     );
-  const setValidCell = (tableId, rowId, rowMap, cellId, cell) => {
-    if (!collHas(rowMap, cellId)) {
-      cellIdsChanged(tableId, rowId, cellId, 1);
-    }
-    const oldCell = mapGet(rowMap, cellId);
-    if (cell !== oldCell) {
-      cellChanged(tableId, rowId, cellId, oldCell, cell);
-      mapSet(rowMap, cellId, cell);
-    }
-  };
-  const setCellIntoDefaultRow = (tableId, tableMap, rowId, cellId, validCell) =>
+  const setValidCell = (tableId, rowId, rowMap, cellId, cell, skipMiddleware) =>
+    ifTransformed(
+      cell,
+      () =>
+        ifNotUndefined(
+          skipMiddleware ? void 0 : middleware[4],
+          (willSetCell) =>
+            whileMutating(() => willSetCell(tableId, rowId, cellId, cell)),
+          () => cell,
+        ),
+      (cell2) => {
+        if (!collHas(rowMap, cellId)) {
+          cellIdsChanged(tableId, rowId, cellId, 1);
+        }
+        const oldCell = mapGet(rowMap, cellId);
+        if (cell2 !== oldCell) {
+          cellChanged(tableId, rowId, cellId, oldCell, cell2);
+          mapSet(rowMap, cellId, cell2);
+        }
+      },
+    );
+  const setCellIntoNewRow = (
+    tableId,
+    tableMap,
+    rowId,
+    cellId,
+    validCell,
+    skipMiddleware,
+  ) =>
     ifNotUndefined(
       mapGet(tableMap, rowId),
-      (rowMap) => setValidCell(tableId, rowId, rowMap, cellId, validCell),
-      () =>
-        setValidRow(
-          tableId,
-          tableMap,
-          rowId,
+      (rowMap) =>
+        setValidCell(tableId, rowId, rowMap, cellId, validCell, skipMiddleware),
+      () => {
+        const rowMap = mapNew();
+        mapSet(tableMap, rowId, rowMap);
+        rowIdsChanged(tableId, rowId, 1);
+        objMap(
           addDefaultsToRow({[cellId]: validCell}, tableId, rowId),
-        ),
+          (cell, cellId2) =>
+            setValidCell(tableId, rowId, rowMap, cellId2, cell, skipMiddleware),
+        );
+      },
     );
-  const setOrDelValues = (values) =>
-    objIsEmpty(values) ? delValues() : setValues(values);
-  const setValidValues = (values) =>
-    mapMatch(
-      valuesMap,
+  const setValidValues = (values, forceDel) =>
+    ifTransformed(
       values,
-      (_valuesMap, valueId, value) => setValidValue(valueId, value),
-      (_valuesMap, valueId) => delValidValue(valueId),
+      () =>
+        forceDel
+          ? values
+          : ifNotUndefined(
+              middleware[5],
+              (willSetValues) =>
+                whileMutating(() => willSetValues(structuredClone(values))),
+              () => values,
+            ),
+      (validValues) =>
+        mapMatch(
+          valuesMap,
+          validValues,
+          (_valuesMap, valueId, value) => setValidValue(valueId, value),
+          (_valuesMap, valueId) => delValidValue(valueId),
+        ),
+      objIsEqual,
+    );
+  const setValidValue = (valueId, value, skipMiddleware) =>
+    ifTransformed(
+      value,
+      () =>
+        ifNotUndefined(
+          skipMiddleware ? void 0 : middleware[6],
+          (willSetValue) => whileMutating(() => willSetValue(valueId, value)),
+          () => value,
+        ),
+      (value2) => {
+        if (!collHas(valuesMap, valueId)) {
+          valueIdsChanged(valueId, 1);
+        }
+        const oldValue = mapGet(valuesMap, valueId);
+        if (value2 !== oldValue) {
+          valueChanged(valueId, oldValue, value2);
+          mapSet(valuesMap, valueId, value2);
+        }
+      },
     );
-  const setValidValue = (valueId, value) => {
-    if (!collHas(valuesMap, valueId)) {
-      valueIdsChanged(valueId, 1);
-    }
-    const oldValue = mapGet(valuesMap, valueId);
-    if (value !== oldValue) {
-      valueChanged(valueId, oldValue, value);
-      mapSet(valuesMap, valueId, value);
-    }
-  };
   const getNewRowId = (tableId, reuse) => {
     const [getId] = mapGet(tablePoolFunctions, tableId);
     let rowId;
@@ -829,14 +972,34 @@ const createStore = () => {
     return rowId;
   };
   const getOrCreateTable = (tableId) =>
-    mapGet(tablesMap, tableId) ?? setValidTable(tableId, {});
-  const delValidTable = (tableId) => setValidTable(tableId, {});
+    mapEnsure(tablesMap, tableId, () => {
+      tableIdsChanged(tableId, 1);
+      mapSet(tablePoolFunctions, tableId, getPoolFunctions());
+      mapSet(tableCellIds, tableId, mapNew());
+      return mapNew();
+    });
+  const delValidTable = (tableId) => {
+    if (whileMutating(() => middleware[8]?.(tableId)) ?? true) {
+      return setValidTable(tableId, {}, true);
+    }
+    return mapGet(tablesMap, tableId);
+  };
   const delValidRow = (tableId, tableMap, rowId) => {
-    const [, releaseId] = mapGet(tablePoolFunctions, tableId);
-    releaseId(rowId);
-    setValidRow(tableId, tableMap, rowId, {}, true);
+    if (whileMutating(() => middleware[9]?.(tableId, rowId)) ?? true) {
+      const [, releaseId] = mapGet(tablePoolFunctions, tableId);
+      releaseId(rowId);
+      setValidRow(tableId, tableMap, rowId, {}, true);
+    }
   };
-  const delValidCell = (tableId, table, rowId, row, cellId, forceDel) => {
+  const delValidCell = (
+    tableId,
+    table,
+    rowId,
+    row,
+    cellId,
+    forceDel,
+    skipMiddleware,
+  ) => {
     const defaultCell = mapGet(
       mapGet(tablesSchemaRowCache, tableId)?.[0],
       cellId,
@@ -844,34 +1007,44 @@ const createStore = () => {
     if (!isUndefined(defaultCell) && !forceDel) {
       return setValidCell(tableId, rowId, row, cellId, defaultCell);
     }
-    const delCell2 = (cellId2) => {
-      cellChanged(tableId, rowId, cellId2, mapGet(row, cellId2));
-      cellIdsChanged(tableId, rowId, cellId2, -1);
-      mapSet(row, cellId2);
-    };
-    if (isUndefined(defaultCell)) {
-      delCell2(cellId);
-    } else {
-      mapForEach(row, delCell2);
-    }
-    if (collIsEmpty(row)) {
-      rowIdsChanged(tableId, rowId, -1);
-      if (collIsEmpty(mapSet(table, rowId))) {
-        tableIdsChanged(tableId, -1);
-        mapSet(tablesMap, tableId);
-        mapSet(tablePoolFunctions, tableId);
-        mapSet(tableCellIds, tableId);
+    if (
+      skipMiddleware ||
+      (whileMutating(() => middleware[10]?.(tableId, rowId, cellId)) ?? true)
+    ) {
+      const delCell2 = (cellId2) => {
+        cellChanged(tableId, rowId, cellId2, mapGet(row, cellId2));
+        cellIdsChanged(tableId, rowId, cellId2, -1);
+        mapSet(row, cellId2);
+      };
+      if (isUndefined(defaultCell)) {
+        delCell2(cellId);
+      } else {
+        mapForEach(row, delCell2);
+      }
+      if (collIsEmpty(row)) {
+        rowIdsChanged(tableId, rowId, -1);
+        if (collIsEmpty(mapSet(table, rowId))) {
+          tableIdsChanged(tableId, -1);
+          mapSet(tablesMap, tableId);
+          mapSet(tablePoolFunctions, tableId);
+          mapSet(tableCellIds, tableId);
+        }
       }
     }
   };
-  const delValidValue = (valueId) => {
+  const delValidValue = (valueId, skipMiddleware) => {
     const defaultValue = mapGet(valuesDefaulted, valueId);
     if (!isUndefined(defaultValue)) {
       return setValidValue(valueId, defaultValue);
     }
-    valueChanged(valueId, mapGet(valuesMap, valueId));
-    valueIdsChanged(valueId, -1);
-    mapSet(valuesMap, valueId);
+    if (
+      skipMiddleware ||
+      (whileMutating(() => middleware[12]?.(valueId)) ?? true)
+    ) {
+      valueChanged(valueId, mapGet(valuesMap, valueId));
+      valueIdsChanged(valueId, -1);
+      mapSet(valuesMap, valueId);
+    }
   };
   const tableIdsChanged = (tableId, addedOrRemoved) =>
     idsChanged(changedTableIds, tableId, addedOrRemoved);
@@ -1330,14 +1503,14 @@ const createStore = () => {
         if (validateRow(tableId2, rowId2, partialRow, 1)) {
           const table = getOrCreateTable(tableId2);
           objMap(partialRow, (cell, cellId) =>
-            setCellIntoDefaultRow(tableId2, table, rowId2, cellId, cell),
+            setCellIntoNewRow(tableId2, table, rowId2, cellId, cell),
           );
         }
       },
       tableId,
       rowId,
     );
-  const setCell = (tableId, rowId, cellId, cell) =>
+  const setCell = (tableId, rowId, cellId, cell, skipMiddleware) =>
     fluentTransaction(
       (tableId2, rowId2, cellId2) =>
         ifNotUndefined(
@@ -1348,12 +1521,13 @@ const createStore = () => {
             isFunction(cell) ? cell(getCell(tableId2, rowId2, cellId2)) : cell,
           ),
           (validCell) =>
-            setCellIntoDefaultRow(
+            setCellIntoNewRow(
               tableId2,
               getOrCreateTable(tableId2),
               rowId2,
               cellId2,
               validCell,
+              skipMiddleware,
             ),
         ),
       tableId,
@@ -1372,7 +1546,7 @@ const createStore = () => {
           )
         : 0,
     );
-  const setValue = (valueId, value) =>
+  const setValue = (valueId, value, skipMiddleware) =>
     fluentTransaction(
       (valueId2) =>
         ifNotUndefined(
@@ -1380,27 +1554,40 @@ const createStore = () => {
             valueId2,
             isFunction(value) ? value(getValue(valueId2)) : value,
           ),
-          (validValue) => setValidValue(valueId2, validValue),
+          (validValue) => setValidValue(valueId2, validValue, skipMiddleware),
         ),
       valueId,
     );
   const applyChanges = (changes) =>
-    fluentTransaction(() => {
-      objMap(changes[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(changes[1], (value, valueId) =>
-        setOrDelValue(store, valueId, value),
-      );
-    });
+    fluentTransaction(() =>
+      ifTransformed(
+        changes,
+        () =>
+          ifNotUndefined(
+            middleware[13],
+            (willApplyChanges) =>
+              whileMutating(() => willApplyChanges(structuredClone(changes))),
+            () => changes,
+          ),
+        (changes2) => {
+          objMap(changes2[0], (table, tableId) =>
+            isUndefined(table)
+              ? delTable(tableId)
+              : objMap(table, (row, rowId) =>
+                  isUndefined(row)
+                    ? delRow(tableId, rowId)
+                    : objMap(row, (cell, cellId) =>
+                        setOrDelCell(tableId, rowId, cellId, cell),
+                      ),
+                ),
+          );
+          objMap(changes2[1], (value, valueId) =>
+            setOrDelValue(valueId, value),
+          );
+        },
+        contentOrChangesIsEqual,
+      ),
+    );
   const setTablesJson = (tablesJson) => {
     tryCatch(() => setOrDelTables(jsonParse(tablesJson)));
     return store;
@@ -1447,7 +1634,12 @@ const createStore = () => {
       setTablesSchema(tablesSchema);
       setValuesSchema(valuesSchema);
     });
-  const delTables = () => fluentTransaction(() => setValidTables({}));
+  const delTables = () =>
+    fluentTransaction(() =>
+      (whileMutating(() => middleware[7]?.()) ?? true)
+        ? setValidTables({}, true)
+        : 0,
+    );
   const delTable = (tableId) =>
     fluentTransaction(
       (tableId2) =>
@@ -1465,7 +1657,7 @@ const createStore = () => {
       tableId,
       rowId,
     );
-  const delCell = (tableId, rowId, cellId, forceDel) =>
+  const delCell = (tableId, rowId, cellId, forceDel, skipMiddleware) =>
     fluentTransaction(
       (tableId2, rowId2, cellId2) =>
         ifNotUndefined(mapGet(tablesMap, tableId2), (tableMap) =>
@@ -1478,6 +1670,7 @@ const createStore = () => {
                   rowMap,
                   cellId2,
                   forceDel,
+                  skipMiddleware,
                 )
               : 0,
           ),
@@ -1486,11 +1679,18 @@ const createStore = () => {
       rowId,
       cellId,
     );
-  const delValues = () => fluentTransaction(() => setValidValues({}));
-  const delValue = (valueId) =>
+  const delValues = () =>
+    fluentTransaction(() =>
+      (whileMutating(() => middleware[11]?.()) ?? true)
+        ? setValidValues({}, true)
+        : 0,
+    );
+  const delValue = (valueId, skipMiddleware) =>
     fluentTransaction(
       (valueId2) =>
-        collHas(valuesMap, valueId2) ? delValidValue(valueId2) : 0,
+        collHas(valuesMap, valueId2)
+          ? delValidValue(valueId2, skipMiddleware)
+          : 0,
       valueId,
     );
   const delTablesSchema = () =>
@@ -1572,27 +1772,27 @@ const createStore = () => {
       transactions--;
       if (transactions == 0) {
         transactions = 1;
-        mutating = 1;
-        callInvalidCellListeners(1);
-        if (!collIsEmpty(changedCells)) {
-          callTabularListenersForChanges(1);
-        }
-        callInvalidValueListeners(1);
-        if (!collIsEmpty(changedValues)) {
-          callValuesListenersForChanges(1);
-        }
-        mutating = 0;
+        whileMutating(() => {
+          callInvalidCellListeners(1);
+          if (!collIsEmpty(changedCells)) {
+            callTabularListenersForChanges(1);
+          }
+          callInvalidValueListeners(1);
+          if (!collIsEmpty(changedValues)) {
+            callValuesListenersForChanges(1);
+          }
+        });
         if (doRollback?.(store)) {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
-                setOrDelCell(store, tableId, rowId, cellId, oldCell),
+                setOrDelCell(tableId, rowId, cellId, oldCell, true),
               ),
             ),
           );
           collClear(changedCells);
           collForEach(changedValues, ([oldValue], valueId) =>
-            setOrDelValue(store, valueId, oldValue),
+            setOrDelValue(valueId, oldValue, true),
           );
           collClear(changedValues);
         }
@@ -1719,6 +1919,38 @@ const createStore = () => {
       collSize2(startTransactionListeners) +
       pairCollSize2(finishTransactionListeners),
   });
+  const setMiddleware = (
+    willSetContent,
+    willSetTables,
+    willSetTable,
+    willSetRow,
+    willSetCell,
+    willSetValues,
+    willSetValue,
+    willDelTables,
+    willDelTable,
+    willDelRow,
+    willDelCell,
+    willDelValues,
+    willDelValue,
+    willApplyChanges,
+  ) =>
+    (middleware = [
+      willSetContent,
+      willSetTables,
+      willSetTable,
+      willSetRow,
+      willSetCell,
+      willSetValues,
+      willSetValue,
+      willDelTables,
+      willDelTable,
+      willDelRow,
+      willDelCell,
+      willDelValues,
+      willDelValue,
+      willApplyChanges,
+    ]);
   const setInternalListeners = (
     preStartTransaction,
     preFinishTransaction,
@@ -1812,6 +2044,9 @@ const createStore = () => {
     addListener,
     callListeners,
     setInternalListeners,
+    setMiddleware,
+    setOrDelCell,
+    setOrDelValue,
   };
   objMap(
     {
@@ -2368,7 +2603,8 @@ const createMergeableStore = (uniqueId, getNow) => {
         strStartsWith(name, DEL) ||
         strStartsWith(name, 'apply') ||
         strEndsWith(name, TRANSACTION) ||
-        name == 'call' + LISTENER
+        name == 'call' + LISTENER ||
+        name == 'use'
           ? (...args) => {
               method(...args);
               return mergeableStore;