tinybase 2.0.0-beta.0 → 2.0.0-beta.3

package/lib/debug/tinybase.js

@@ -14,6 +14,18 @@ const SUM = 'sum';
 const AVG = 'avg';
 const MIN = 'min';
 const MAX = 'max';
+const LISTENER = 'Listener';
+const RESULT = 'Result';
+const GET = 'get';
+const ADD = 'add';
+const TABLES = 'Tables';
+const TABLE_IDS = 'TableIds';
+const TABLE = 'Table';
+const ROW_IDS = 'RowIds';
+const SORTED_ROW_IDS = 'SortedRowIds';
+const ROW = 'Row';
+const CELL_IDS = 'CellIds';
+const CELL = 'Cell';
 
 const arrayHas = (array, value) => array.includes(value);
 const arrayEvery = (array, cb) => array.every(cb);
@@ -86,7 +98,7 @@ const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
 const mapEnsure = (map, key, getDefaultValue) => {
   if (!collHas(map, key)) {
-    map.set(key, getDefaultValue());
+    mapSet(map, key, getDefaultValue());
   }
   return mapGet(map, key);
 };
@@ -284,32 +296,32 @@ const getCreateFunction = (getFunction) => {
 };
 
 const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
-  const sets = [];
-  const deep = (set, p) =>
+  const leaves = [];
+  const deep = (node, p) =>
     p == arrayLength(path)
-      ? arrayPush(sets, set)
-      : arrayForEach([path[p], null], (id) => deep(mapGet(set, id), p + 1));
+      ? arrayPush(leaves, node)
+      : path[p] === null
+      ? collForEach(node, (node2) => deep(node2, p + 1))
+      : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
   deep(deepIdSet, 0);
-  return sets;
+  return leaves;
 };
 const getListenerFunctions = (getThing) => {
   let thing;
   let nextId = 0;
   const listenerPool = [];
   const allListeners = mapNew();
-  const addListener = (listener, idSetNode, idOrNulls) => {
+  const addListener = (listener, idSetNode, path) => {
     thing ??= getThing();
     const id = arrayPop(listenerPool) ?? EMPTY_STRING + nextId++;
-    mapSet(allListeners, id, [listener, idSetNode, idOrNulls]);
-    setAdd(visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], setNew), id);
+    mapSet(allListeners, id, [listener, idSetNode, path]);
+    setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
     return id;
   };
   const callListeners = (idSetNode, ids, ...extraArgs) =>
     arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
       collForEach(set, (id) =>
-        ifNotUndefined(mapGet(allListeners, id), ([listener]) =>
-          listener(thing, ...(ids ?? []), ...extraArgs),
-        ),
+        mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs),
       ),
     );
   const delListener = (id) =>
@@ -324,8 +336,6 @@ const getListenerFunctions = (getThing) => {
       }
       return idOrNulls;
     });
-  const hasListeners = (idSetNode, ids) =>
-    !arrayEvery(getWildcardedLeaves(idSetNode, ids), isUndefined);
   const callListener = (id, idNullGetters, extraArgsGetter) =>
     ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls = []]) => {
       const callWithIds = (...ids) => {
@@ -340,7 +350,7 @@ const getListenerFunctions = (getThing) => {
       };
       callWithIds();
     });
-  return [addListener, callListeners, delListener, hasListeners, callListener];
+  return [addListener, callListeners, delListener, callListener];
 };
 
 const object = Object;
@@ -565,6 +575,7 @@ const createCheckpoints = getCreateFunction((store) => {
 });
 
 const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
+const id = (key) => EMPTY_STRING + key;
 
 const createIndexes = getCreateFunction((store) => {
   const sliceIdsListeners = mapNew();
@@ -1081,6 +1092,7 @@ const createRemotePersister = (
 };
 
 const createQueries = getCreateFunction((store) => {
+  const createStore = store.createStore;
   const [
     getStore,
     getQueryIds,
@@ -1096,25 +1108,26 @@ const createQueries = getCreateFunction((store) => {
     addStoreListeners,
     delStoreListeners,
   ] = getDefinableFunctions(store, () => true, getUndefined);
-  const preStore1 = store.createStore();
-  const preStore2 = store.createStore();
-  const resultStore = store.createStore();
+  const preStore = createStore();
+  const resultStore = createStore();
   const preStoreListenerIds = mapNew();
-  const addPreStoreListener = (preStore, queryId, ...listenerIds) =>
+  const addPreStoreListener = (preStore2, queryId, ...listenerIds) =>
     arrayForEach(listenerIds, (listenerId) =>
       setAdd(
         mapEnsure(
           mapEnsure(preStoreListenerIds, queryId, mapNew),
-          preStore,
+          preStore2,
           setNew,
         ),
         listenerId,
       ),
     );
+  const cleanPreStores = (queryId) =>
+    arrayForEach([resultStore, preStore], (store2) => store2.delTable(queryId));
   const synchronizeTransactions = (queryId, fromStore, toStore) =>
-    addStoreListeners(
+    addPreStoreListener(
+      fromStore,
       queryId,
-      0,
       fromStore.addWillFinishTransactionListener(toStore.startTransaction),
       fromStore.addDidFinishTransactionListener(() =>
         toStore.finishTransaction(),
@@ -1122,16 +1135,12 @@ const createQueries = getCreateFunction((store) => {
     );
   const setQueryDefinition = (queryId, tableId, build) => {
     setDefinition(queryId, tableId);
-    preStore1.delTable(queryId);
-    preStore2.delTable(queryId);
-    resultStore.delTable(queryId);
-    let offsetLimit;
+    cleanPreStores(queryId);
     const selectEntries = [];
     const joinEntries = [[null, [tableId, null, null, [], mapNew()]]];
     const wheres = [];
     const groupEntries = [];
     const havings = [];
-    const orders = [];
     const select = (arg1, arg2) => {
       const selectEntry = isFunction(arg1)
         ? [arrayLength(selectEntries) + EMPTY_STRING, arg1]
@@ -1197,17 +1206,7 @@ const createQueries = getCreateFunction((store) => {
           : (getSelectedOrGroupedCell) =>
               getSelectedOrGroupedCell(arg1) === arg2,
       );
-    const order = (arg1, descending) =>
-      arrayPush(orders, [
-        isFunction(arg1)
-          ? arg1
-          : (getSelectedOrGroupedCell) => getSelectedOrGroupedCell(arg1) ?? 0,
-        descending,
-      ]);
-    const limit = (arg1, arg2) => {
-      offsetLimit = isUndefined(arg2) ? [0, arg1] : [arg1, arg2];
-    };
-    build({select, join, where, group, having, order, limit});
+    build({select, join, where, group, having});
     const selects = mapNew(selectEntries);
     if (collIsEmpty(selects)) {
       return queries;
@@ -1219,95 +1218,11 @@ const createQueries = getCreateFunction((store) => {
       ),
     );
     const groups = mapNew(groupEntries);
-    let selectJoinWhereStore = preStore1;
-    let groupHavingStore = preStore2;
-    if (arrayIsEmpty(orders) && isUndefined(offsetLimit)) {
-      groupHavingStore = resultStore;
-    } else {
-      synchronizeTransactions(queryId, groupHavingStore, resultStore);
-      const groupRowIdSorter = (rowId1, rowId2) => {
-        const sortKeys1 = mapGet(sortKeysByGroupRowId, rowId1) ?? [];
-        const sortKeys2 = mapGet(sortKeysByGroupRowId, rowId2) ?? [];
-        const orderIndex = orders.findIndex(
-          (_order, index) => sortKeys1[index] !== sortKeys2[index],
-        );
-        return orderIndex < 0
-          ? 0
-          : defaultSorter(sortKeys1[orderIndex], sortKeys2[orderIndex]) *
-              (orders[orderIndex][1] ? -1 : 1);
-      };
-      const sortKeysByGroupRowId = mapNew();
-      const sortedGroupRowIds = mapNew();
-      addPreStoreListener(
-        groupHavingStore,
-        queryId,
-        arrayIsEmpty(orders)
-          ? groupHavingStore.addRowIdsListener(queryId, () =>
-              collClear(sortedGroupRowIds),
-            )
-          : groupHavingStore.addRowListener(
-              queryId,
-              null,
-              (_store, _tableId, groupRowId) => {
-                let newSortKeys = null;
-                if (groupHavingStore.hasRow(queryId, groupRowId)) {
-                  const oldSortKeys =
-                    mapGet(sortKeysByGroupRowId, groupRowId) ?? [];
-                  const groupRow = groupHavingStore.getRow(queryId, groupRowId);
-                  const getCell = (getSelectedOrGroupedCell) =>
-                    groupRow[getSelectedOrGroupedCell];
-                  newSortKeys = arrayMap(orders, ([getSortKey]) =>
-                    getSortKey(getCell, groupRowId),
-                  );
-                  if (arrayIsEqual(oldSortKeys, newSortKeys)) {
-                    if (mapGet(sortedGroupRowIds, groupRowId)) {
-                      resultStore.setRow(queryId, groupRowId, groupRow);
-                    }
-                    return;
-                  }
-                }
-                mapSet(sortKeysByGroupRowId, groupRowId, newSortKeys);
-                collClear(sortedGroupRowIds);
-              },
-            ),
-        groupHavingStore.addTableListener(queryId, () => {
-          if (collIsEmpty(sortedGroupRowIds)) {
-            resultStore.delTable(queryId);
-            if (groupHavingStore.hasTable(queryId)) {
-              const groupTable = groupHavingStore.getTable(queryId);
-              arrayForEach(
-                arraySort(objIds(groupTable), groupRowIdSorter),
-                (id) => mapSet(sortedGroupRowIds, id, 0),
-              );
-              arrayForEach(
-                ifNotUndefined(
-                  offsetLimit,
-                  ([offset, limit2]) =>
-                    arraySlice(
-                      mapKeys(sortedGroupRowIds),
-                      offset,
-                      offset + limit2,
-                    ),
-                  () => mapKeys(sortedGroupRowIds),
-                ),
-                (groupRowId) => {
-                  resultStore.setRow(
-                    queryId,
-                    groupRowId,
-                    groupTable[groupRowId],
-                  );
-                  mapSet(sortedGroupRowIds, groupRowId, 1);
-                },
-              );
-            }
-          }
-        }),
-      );
-    }
+    let selectJoinWhereStore = preStore;
     if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
-      selectJoinWhereStore = groupHavingStore;
+      selectJoinWhereStore = resultStore;
     } else {
-      synchronizeTransactions(queryId, selectJoinWhereStore, groupHavingStore);
+      synchronizeTransactions(queryId, selectJoinWhereStore, resultStore);
       const groupedSelectedCellIds = mapNew();
       mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>
         setAdd(mapEnsure(groupedSelectedCellIds, selectedCellId, setNew), [
@@ -1369,8 +1284,8 @@ const createQueries = getCreateFunction((store) => {
               !arrayEvery(havings, (having2) =>
                 having2((cellId) => groupRow[cellId]),
               )
-              ? groupHavingStore.delRow
-              : groupHavingStore.setRow)(queryId, groupRowId, groupRow);
+              ? resultStore.delRow
+              : resultStore.setRow)(queryId, groupRowId, groupRow);
           },
         );
       addPreStoreListener(
@@ -1417,7 +1332,7 @@ const createQueries = getCreateFunction((store) => {
                   ([, selectedRowIds, groupRowId]) => {
                     collDel(selectedRowIds, selectedRowId);
                     if (collIsEmpty(selectedRowIds)) {
-                      groupHavingStore.delRow(queryId, groupRowId);
+                      resultStore.delRow(queryId, groupRowId);
                       return 1;
                     }
                   },
@@ -1447,7 +1362,7 @@ const createQueries = getCreateFunction((store) => {
                     return [
                       mapNew(),
                       setNew(),
-                      groupHavingStore.addRow(queryId, groupRow, 1),
+                      resultStore.addRow(queryId, groupRow, 1),
                       groupRow,
                     ];
                   },
@@ -1554,56 +1469,15 @@ const createQueries = getCreateFunction((store) => {
     return queries;
   };
   const delQueryDefinition = (queryId) => {
-    mapForEach(mapGet(preStoreListenerIds, queryId), (preStore, listenerIds) =>
+    mapForEach(mapGet(preStoreListenerIds, queryId), (preStore2, listenerIds) =>
       collForEach(listenerIds, (listenerId) =>
-        preStore.delListener(listenerId),
+        preStore2.delListener(listenerId),
       ),
     );
+    cleanPreStores(queryId);
     delDefinition(queryId);
     return queries;
   };
-  const getResultTable = (queryId) => resultStore.getTable(queryId);
-  const getResultRowIds = (queryId) => resultStore.getRowIds(queryId);
-  const getResultRow = (queryId, rowId) => resultStore.getRow(queryId, rowId);
-  const getResultCellIds = (queryId, rowId) =>
-    resultStore.getCellIds(queryId, rowId);
-  const getResultCell = (queryId, rowId, cellId) =>
-    resultStore.getCell(queryId, rowId, cellId);
-  const hasResultTable = (queryId) => resultStore.hasTable(queryId);
-  const hasResultRow = (queryId, rowId) => resultStore.hasRow(queryId, rowId);
-  const hasResultCell = (queryId, rowId, cellId) =>
-    resultStore.hasCell(queryId, rowId, cellId);
-  const forEachResultTable = (tableCallback) =>
-    resultStore.forEachTable(tableCallback);
-  const forEachResultRow = (queryId, rowCallback) =>
-    resultStore.forEachRow(queryId, rowCallback);
-  const forEachResultCell = (queryId, rowId, cellCallback) =>
-    resultStore.forEachCell(queryId, rowId, cellCallback);
-  const addResultTableListener = (queryId, listener) =>
-    resultStore.addTableListener(queryId, (_store, ...args) =>
-      listener(queries, ...args),
-    );
-  const addResultRowIdsListener = (queryId, listener, trackReorder) =>
-    resultStore.addRowIdsListener(
-      queryId,
-      (_store, ...args) => listener(queries, ...args),
-      trackReorder,
-    );
-  const addResultRowListener = (queryId, rowId, listener) =>
-    resultStore.addRowListener(queryId, rowId, (_store, ...args) =>
-      listener(queries, ...args),
-    );
-  const addResultCellIdsListener = (queryId, rowId, listener, trackReorder) =>
-    resultStore.addCellIdsListener(
-      queryId,
-      rowId,
-      (_store, ...args) => listener(queries, ...args),
-      trackReorder,
-    );
-  const addResultCellListener = (queryId, rowId, cellId, listener) =>
-    resultStore.addCellListener(queryId, rowId, cellId, (_store, ...args) =>
-      listener(queries, ...args),
-    );
   const delListener = (listenerId) => {
     resultStore.delListener(listenerId);
     return queries;
@@ -1625,26 +1499,34 @@ const createQueries = getCreateFunction((store) => {
     forEachQuery,
     hasQuery,
     getTableId,
-    getResultTable,
-    getResultRowIds,
-    getResultRow,
-    getResultCellIds,
-    getResultCell,
-    hasResultTable,
-    hasResultRow,
-    hasResultCell,
-    forEachResultTable,
-    forEachResultRow,
-    forEachResultCell,
-    addResultTableListener,
-    addResultRowIdsListener,
-    addResultRowListener,
-    addResultCellIdsListener,
-    addResultCellListener,
     delListener,
     destroy,
     getListenerStats,
   };
+  objForEach(
+    {
+      [TABLE]: [1, 1],
+      [ROW_IDS]: [0, 1],
+      [SORTED_ROW_IDS]: [0, 5],
+      [ROW]: [1, 2],
+      [CELL_IDS]: [0, 2],
+      [CELL]: [1, 3],
+    },
+    ([hasAndForEach, argumentCount], gettable) => {
+      arrayForEach(
+        hasAndForEach ? [GET, 'has', 'forEach'] : [GET],
+        (prefix) =>
+          (queries[prefix + RESULT + gettable] = (...args) =>
+            resultStore[prefix + gettable](...args)),
+      );
+      queries[ADD + RESULT + gettable + LISTENER] = (...args) =>
+        resultStore[ADD + gettable + LISTENER](
+          ...arraySlice(args, 0, argumentCount),
+          (_store, ...listenerArgs) =>
+            args[argumentCount](queries, ...listenerArgs),
+        );
+    },
+  );
   return objFreeze(queries);
 });
 
@@ -1837,21 +1719,17 @@ const createRelationships = getCreateFunction((store) => {
 
 const pairNew = (value) => [value, value];
 const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
-const pairCollIsEmpty = (pair) => pairCollSize2(pair) == 0;
 const pairNewMap = () => [mapNew(), mapNew()];
-const pair2CollSize2 = (pair2, func = collSize2) =>
-  pairCollSize2(pair2[0], func) + pairCollSize2(pair2[1], func);
-const pair2NewMap = () => [pairNewMap(), pairNewMap()];
 
 const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
   const idsToDelete = arrayFilter(
     mapKeys(map),
-    (id) => !objHas(toBeLikeObject, id),
+    (id2) => !objHas(toBeLikeObject, id2),
   );
-  arrayForEach(objIds(toBeLikeObject), (id) =>
-    setId(map, id, toBeLikeObject[id]),
+  arrayForEach(objIds(toBeLikeObject), (id2) =>
+    setId(map, id2, toBeLikeObject[id2]),
   );
-  arrayForEach(idsToDelete, (id) => delId(map, id));
+  arrayForEach(idsToDelete, (id2) => delId(map, id2));
   return map;
 };
 const validate = (obj, validateChild, onInvalidObj) => {
@@ -1859,15 +1737,15 @@ const validate = (obj, validateChild, onInvalidObj) => {
     onInvalidObj?.();
     return false;
   }
-  objForEach(obj, (child, id) => {
-    if (!validateChild(child, id)) {
-      objDel(obj, id);
+  objForEach(obj, (child, id2) => {
+    if (!validateChild(child, id2)) {
+      objDel(obj, id2);
     }
   });
   return !objIsEmpty(obj);
 };
-const idsChanged = (changedIds, id, added) =>
-  mapSet(changedIds, id, mapGet(changedIds, id) == -added ? void 0 : added);
+const idsChanged = (changedIds, id2, added) =>
+  mapSet(changedIds, id2, mapGet(changedIds, id2) == -added ? void 0 : added);
 const createStore = () => {
   let hasSchema;
   let cellsTouched;
@@ -1882,26 +1760,22 @@ const createStore = () => {
   const schemaRowCache = mapNew();
   const tablesMap = mapNew();
   const tablesListeners = pairNewMap();
-  const tableIdsListeners = pair2NewMap();
+  const tableIdsListeners = pairNewMap();
   const tableListeners = pairNewMap();
-  const rowIdsListeners = pair2NewMap();
+  const rowIdsListeners = pairNewMap();
+  const sortedRowIdsListeners = pairNewMap();
   const rowListeners = pairNewMap();
-  const cellIdsListeners = pair2NewMap();
+  const cellIdsListeners = pairNewMap();
   const cellListeners = pairNewMap();
   const invalidCellListeners = pairNewMap();
   const finishTransactionListeners = pairNewMap();
-  const [
-    addListener,
-    callListeners,
-    delListenerImpl,
-    hasListeners,
-    callListenerImpl,
-  ] = getListenerFunctions(() => store);
+  const [addListener, callListeners, delListenerImpl, callListenerImpl] =
+    getListenerFunctions(() => store);
   const validateSchema = (schema) =>
     validate(schema, (tableSchema) =>
       validate(tableSchema, (cellSchema) => {
         if (
-          !validate(cellSchema, (_child, id) => arrayHas([TYPE, DEFAULT], id))
+          !validate(cellSchema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))
         ) {
           return false;
         }
@@ -2078,49 +1952,12 @@ const createStore = () => {
     }
   };
   const tableIdsChanged = (tableId, added) =>
-    idsChanged(
-      collIsEmpty(changedTableIds)
-        ? mapSet(
-            changedTableIds,
-            null,
-            hasListeners(tableIdsListeners[0][1]) ||
-              hasListeners(tableIdsListeners[1][1])
-              ? getTableIds()
-              : 0,
-          )
-        : changedTableIds,
-      tableId,
-      added,
-    );
+    idsChanged(changedTableIds, tableId, added);
   const rowIdsChanged = (tableId, rowId, added) =>
-    idsChanged(
-      mapEnsure(changedRowIds, tableId, () =>
-        mapNew([
-          [
-            null,
-            hasListeners(rowIdsListeners[0][1], [tableId]) ||
-            hasListeners(rowIdsListeners[1][1], [tableId])
-              ? getRowIds(tableId)
-              : 0,
-          ],
-        ]),
-      ),
-      rowId,
-      added,
-    );
+    idsChanged(mapEnsure(changedRowIds, tableId, mapNew), rowId, added);
   const cellIdsChanged = (tableId, rowId, cellId, added) =>
     idsChanged(
-      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, () =>
-        mapNew([
-          [
-            null,
-            hasListeners(cellIdsListeners[0][1], [tableId, rowId]) ||
-            hasListeners(cellIdsListeners[1][1], [tableId, rowId])
-              ? getCellIds(tableId, rowId)
-              : 0,
-          ],
-        ]),
-      ),
+      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),
       cellId,
       added,
     );
@@ -2163,23 +2000,21 @@ const createStore = () => {
             ),
         )
       : 0;
-  const callIdsListenersIfChanged = (listeners, changedIds, getIds, ids) => {
-    if (collSize(changedIds) > 1) {
-      callListeners(listeners[0], ids);
-      callListeners(listeners[1], ids);
-    } else if (
-      !collIsEmpty(changedIds) &&
-      mapGet(changedIds, null) != 0 &&
-      !arrayIsEqual(mapGet(changedIds, null), getIds(...(ids ?? [])))
-    ) {
-      callListeners(listeners[1], ids);
+  const callIdsListenersIfChanged = (listeners, changedIds, ids) => {
+    if (!collIsEmpty(changedIds)) {
+      callListeners(listeners, ids);
+      return 1;
     }
   };
   const callListenersForChanges = (mutator) => {
+    const emptySortedRowIdListeners = collIsEmpty(
+      sortedRowIdsListeners[mutator],
+    );
     const emptyIdListeners =
-      pairCollIsEmpty(cellIdsListeners[mutator]) &&
-      pairCollIsEmpty(rowIdsListeners[mutator]) &&
-      pairCollIsEmpty(tableIdsListeners[mutator]);
+      collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(rowIdsListeners[mutator]) &&
+      emptySortedRowIdListeners &&
+      collIsEmpty(tableIdsListeners[mutator]);
     const emptyOtherListeners =
       collIsEmpty(cellListeners[mutator]) &&
       collIsEmpty(rowListeners[mutator]) &&
@@ -2197,27 +2032,45 @@ const createStore = () => {
       if (!emptyIdListeners) {
         collForEach(changes[2], (rowCellIds, tableId) =>
           collForEach(rowCellIds, (changedIds, rowId) =>
-            callIdsListenersIfChanged(
-              cellIdsListeners[mutator],
-              changedIds,
-              getCellIds,
-              [tableId, rowId],
-            ),
+            callIdsListenersIfChanged(cellIdsListeners[mutator], changedIds, [
+              tableId,
+              rowId,
+            ]),
           ),
         );
-        collForEach(changes[1], (changedIds, tableId) =>
-          callIdsListenersIfChanged(
-            rowIdsListeners[mutator],
-            changedIds,
-            getRowIds,
-            [tableId],
-          ),
-        );
-        callIdsListenersIfChanged(
-          tableIdsListeners[mutator],
-          changes[0],
-          getTableIds,
-        );
+        const calledSortableTableIds = setNew();
+        collForEach(changes[1], (changedIds, tableId) => {
+          if (
+            callIdsListenersIfChanged(rowIdsListeners[mutator], changedIds, [
+              tableId,
+            ]) &&
+            !emptySortedRowIdListeners
+          ) {
+            callListeners(sortedRowIdsListeners[mutator], [tableId, null]);
+            setAdd(calledSortableTableIds, tableId);
+          }
+        });
+        if (!emptySortedRowIdListeners) {
+          collForEach(changes[3], (rows, tableId) => {
+            if (!collHas(calledSortableTableIds, tableId)) {
+              const sortableCellIds = setNew();
+              collForEach(rows, (cells) =>
+                collForEach(cells, ([oldCell, newCell], cellId) =>
+                  newCell !== oldCell
+                    ? setAdd(sortableCellIds, cellId)
+                    : collDel(cells, cellId),
+                ),
+              );
+              collForEach(sortableCellIds, (cellId) =>
+                callListeners(sortedRowIdsListeners[mutator], [
+                  tableId,
+                  cellId,
+                ]),
+              );
+            }
+          });
+        }
+        callIdsListenersIfChanged(tableIdsListeners[mutator], changes[0]);
       }
       if (!emptyOtherListeners) {
         let tablesChanged;
@@ -2255,26 +2108,49 @@ const createStore = () => {
       }
     }
   };
-  const fluentTransaction = (actions) => {
-    transaction(actions);
+  const fluentTransaction = (actions, ...args) => {
+    transaction(() => actions(...arrayMap(args, id)));
     return store;
   };
   const getTables = () =>
     mapToObj(tablesMap, (table) => mapToObj(table, mapToObj));
   const getTableIds = () => mapKeys(tablesMap);
-  const getTable = (tableId) => mapToObj(mapGet(tablesMap, tableId), mapToObj);
-  const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, tableId));
+  const getTable = (tableId) =>
+    mapToObj(mapGet(tablesMap, id(tableId)), mapToObj);
+  const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, id(tableId)));
+  const getSortedRowIds = (tableId, cellId, descending, offset = 0, limit) => {
+    const cells = [];
+    mapForEach(mapGet(tablesMap, id(tableId)), (rowId, row) =>
+      arrayPush(cells, [
+        isUndefined(cellId) ? rowId : mapGet(row, id(cellId)),
+        rowId,
+      ]),
+    );
+    return arrayMap(
+      arraySlice(
+        arraySort(
+          cells,
+          ([cell1], [cell2]) =>
+            defaultSorter(cell1, cell2) * (descending ? -1 : 1),
+        ),
+        offset,
+        isUndefined(limit) ? limit : offset + limit,
+      ),
+      ([, rowId]) => rowId,
+    );
+  };
   const getRow = (tableId, rowId) =>
-    mapToObj(mapGet(mapGet(tablesMap, tableId), rowId));
+    mapToObj(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));
   const getCellIds = (tableId, rowId) =>
-    mapKeys(mapGet(mapGet(tablesMap, tableId), rowId));
+    mapKeys(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));
   const getCell = (tableId, rowId, cellId) =>
-    mapGet(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+    mapGet(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));
   const hasTables = () => !collIsEmpty(tablesMap);
-  const hasTable = (tableId) => collHas(tablesMap, tableId);
-  const hasRow = (tableId, rowId) => collHas(mapGet(tablesMap, tableId), rowId);
+  const hasTable = (tableId) => collHas(tablesMap, id(tableId));
+  const hasRow = (tableId, rowId) =>
+    collHas(mapGet(tablesMap, id(tableId)), id(rowId));
   const hasCell = (tableId, rowId, cellId) =>
-    collHas(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+    collHas(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));
   const getJson = () => jsonString(tablesMap);
   const getSchemaJson = () => jsonString(schemaMap);
   const setTables = (tables) =>
@@ -2282,17 +2158,28 @@ const createStore = () => {
       validateTables(tables) ? setValidTables(tables) : 0,
     );
   const setTable = (tableId, table) =>
-    fluentTransaction(() =>
-      validateTable(table, tableId) ? setValidTable(tableId, table) : 0,
+    fluentTransaction(
+      (tableId2) =>
+        validateTable(table, tableId2) ? setValidTable(tableId2, table) : 0,
+      tableId,
     );
   const setRow = (tableId, rowId, row) =>
-    fluentTransaction(() =>
-      validateRow(tableId, rowId, row)
-        ? setValidRow(tableId, getOrCreateTable(tableId), rowId, row)
-        : 0,
+    fluentTransaction(
+      (tableId2, rowId2) =>
+        validateRow(id(tableId2), id(rowId2), row)
+          ? setValidRow(
+              id(tableId2),
+              getOrCreateTable(id(tableId2)),
+              id(rowId2),
+              row,
+            )
+          : 0,
+      tableId,
+      rowId,
     );
   const addRow = (tableId, row, forceId) =>
     transaction(() => {
+      tableId = id(tableId);
       const isValidRow = validateRow(tableId, void 0, row);
       const rowId =
         isValidRow || forceId
@@ -2304,32 +2191,40 @@ const createStore = () => {
       return rowId;
     });
   const setPartialRow = (tableId, rowId, partialRow) =>
-    fluentTransaction(() => {
-      if (validateRow(tableId, rowId, partialRow, 1)) {
-        const table = getOrCreateTable(tableId);
-        objForEach(partialRow, (cell, cellId) =>
-          setCellIntoDefaultRow(tableId, table, rowId, cellId, cell),
-        );
-      }
-    });
+    fluentTransaction(
+      (tableId2, rowId2) => {
+        if (validateRow(tableId2, rowId2, partialRow, 1)) {
+          const table = getOrCreateTable(tableId2);
+          objForEach(partialRow, (cell, cellId) =>
+            setCellIntoDefaultRow(tableId2, table, rowId2, cellId, cell),
+          );
+        }
+      },
+      tableId,
+      rowId,
+    );
   const setCell = (tableId, rowId, cellId, cell) =>
-    fluentTransaction(() =>
-      ifNotUndefined(
-        getValidatedCell(
-          tableId,
-          rowId,
-          cellId,
-          isFunction(cell) ? cell(getCell(tableId, rowId, cellId)) : cell,
-        ),
-        (validCell) =>
-          setCellIntoDefaultRow(
-            tableId,
-            getOrCreateTable(tableId),
-            rowId,
-            cellId,
-            validCell,
+    fluentTransaction(
+      (tableId2, rowId2, cellId2) =>
+        ifNotUndefined(
+          getValidatedCell(
+            tableId2,
+            rowId2,
+            cellId2,
+            isFunction(cell) ? cell(getCell(tableId2, rowId2, cellId2)) : cell,
           ),
-      ),
+          (validCell) =>
+            setCellIntoDefaultRow(
+              tableId2,
+              getOrCreateTable(tableId2),
+              rowId2,
+              cellId2,
+              validCell,
+            ),
+        ),
+      tableId,
+      rowId,
+      cellId,
     );
   const setJson = (json) => {
     try {
@@ -2350,24 +2245,42 @@ const createStore = () => {
     });
   const delTables = () => fluentTransaction(() => setValidTables({}));
   const delTable = (tableId) =>
-    fluentTransaction(() =>
-      collHas(tablesMap, tableId) ? delValidTable(tableId) : 0,
+    fluentTransaction(
+      (tableId2) =>
+        collHas(tablesMap, tableId2) ? delValidTable(tableId2) : 0,
+      tableId,
     );
   const delRow = (tableId, rowId) =>
-    fluentTransaction(() =>
-      ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) =>
-        collHas(tableMap, rowId) ? delValidRow(tableId, tableMap, rowId) : 0,
-      ),
+    fluentTransaction(
+      (tableId2, rowId2) =>
+        ifNotUndefined(mapGet(tablesMap, tableId2), (tableMap) =>
+          collHas(tableMap, rowId2)
+            ? delValidRow(tableId2, tableMap, rowId2)
+            : 0,
+        ),
+      tableId,
+      rowId,
     );
   const delCell = (tableId, rowId, cellId, forceDel) =>
-    fluentTransaction(() =>
-      ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) =>
-        ifNotUndefined(mapGet(tableMap, rowId), (rowMap) =>
-          collHas(rowMap, cellId)
-            ? delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel)
-            : 0,
+    fluentTransaction(
+      (tableId2, rowId2, cellId2) =>
+        ifNotUndefined(mapGet(tablesMap, tableId2), (tableMap) =>
+          ifNotUndefined(mapGet(tableMap, rowId2), (rowMap) =>
+            collHas(rowMap, cellId2)
+              ? delValidCell(
+                  tableId2,
+                  tableMap,
+                  rowId2,
+                  rowMap,
+                  cellId2,
+                  forceDel,
+                )
+              : 0,
+          ),
         ),
-      ),
+      tableId,
+      rowId,
+      cellId,
     );
   const delSchema = () =>
     fluentTransaction(() => {
@@ -2422,9 +2335,7 @@ const createStore = () => {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
-                isUndefined(oldCell)
-                  ? delCell(tableId, rowId, cellId, true)
-                  : setCell(tableId, rowId, cellId, oldCell),
+                setOrDelCell(store, tableId, rowId, cellId, oldCell),
               ),
             ),
           );
@@ -2463,52 +2374,53 @@ const createStore = () => {
       ),
     );
   const forEachRow = (tableId, rowCallback) =>
-    collForEach(mapGet(tablesMap, tableId), (rowMap, rowId) =>
+    collForEach(mapGet(tablesMap, id(tableId)), (rowMap, rowId) =>
       rowCallback(rowId, (cellCallback) => mapForEach(rowMap, cellCallback)),
     );
   const forEachCell = (tableId, rowId, cellCallback) =>
-    mapForEach(mapGet(mapGet(tablesMap, tableId), rowId), cellCallback);
-  const addTablesListener = (listener, mutator) =>
-    addListener(listener, tablesListeners[mutator ? 1 : 0]);
-  const addTableIdsListener = (listener, trackReorder, mutator) =>
-    addListener(
-      listener,
-      tableIdsListeners[mutator ? 1 : 0][trackReorder ? 1 : 0],
-    );
-  const addTableListener = (tableId, listener, mutator) =>
-    addListener(listener, tableListeners[mutator ? 1 : 0], [tableId]);
-  const addRowIdsListener = (tableId, listener, trackReorder, mutator) =>
-    addListener(
-      listener,
-      rowIdsListeners[mutator ? 1 : 0][trackReorder ? 1 : 0],
-      [tableId],
-    );
-  const addRowListener = (tableId, rowId, listener, mutator) =>
-    addListener(listener, rowListeners[mutator ? 1 : 0], [tableId, rowId]);
-  const addCellIdsListener = (
+    mapForEach(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), cellCallback);
+  const addSortedRowIdsListener = (
     tableId,
-    rowId,
+    cellId,
+    descending,
+    offset,
+    limit,
     listener,
-    trackReorder,
     mutator,
-  ) =>
-    addListener(
-      listener,
-      cellIdsListeners[mutator ? 1 : 0][trackReorder ? 1 : 0],
-      [tableId, rowId],
-    );
-  const addCellListener = (tableId, rowId, cellId, listener, mutator) =>
-    addListener(listener, cellListeners[mutator ? 1 : 0], [
-      tableId,
-      rowId,
-      cellId,
-    ]);
-  const addInvalidCellListener = (tableId, rowId, cellId, listener, mutator) =>
-    addListener(listener, invalidCellListeners[mutator ? 1 : 0], [
+  ) => {
+    let sortedRowIds = getSortedRowIds(
       tableId,
-      rowId,
       cellId,
-    ]);
+      descending,
+      offset,
+      limit,
+    );
+    return addListener(
+      () => {
+        const newSortedRowIds = getSortedRowIds(
+          tableId,
+          cellId,
+          descending,
+          offset,
+          limit,
+        );
+        if (!arrayIsEqual(newSortedRowIds, sortedRowIds)) {
+          sortedRowIds = newSortedRowIds;
+          listener(
+            store,
+            tableId,
+            cellId,
+            descending,
+            offset,
+            limit,
+            sortedRowIds,
+          );
+        }
+      },
+      sortedRowIdsListeners[mutator ? 1 : 0],
+      [tableId, cellId],
+    );
+  };
   const addWillFinishTransactionListener = (listener) =>
     addListener(listener, finishTransactionListeners[0]);
   const addDidFinishTransactionListener = (listener) =>
@@ -2525,11 +2437,12 @@ const createStore = () => {
   };
   const getListenerStats = () => ({
     tables: pairCollSize2(tablesListeners),
-    tableIds: pair2CollSize2(tableIdsListeners),
+    tableIds: pairCollSize2(tableIdsListeners),
     table: pairCollSize2(tableListeners),
-    rowIds: pair2CollSize2(rowIdsListeners),
+    rowIds: pairCollSize2(rowIdsListeners),
+    sortedRowIds: pairCollSize2(sortedRowIdsListeners),
     row: pairCollSize2(rowListeners, collSize3),
-    cellIds: pair2CollSize2(cellIdsListeners, collSize3),
+    cellIds: pairCollSize2(cellIdsListeners, collSize3),
     cell: pairCollSize2(cellListeners, collSize4),
     invalidCell: pairCollSize2(invalidCellListeners, collSize4),
     transaction: pairCollSize2(finishTransactionListeners),
@@ -2539,6 +2452,7 @@ const createStore = () => {
     getTableIds,
     getTable,
     getRowIds,
+    getSortedRowIds,
     getRow,
     getCellIds,
     getCell,
@@ -2567,14 +2481,7 @@ const createStore = () => {
     forEachTable,
     forEachRow,
     forEachCell,
-    addTablesListener,
-    addTableIdsListener,
-    addTableListener,
-    addRowIdsListener,
-    addRowListener,
-    addCellIdsListener,
-    addCellListener,
-    addInvalidCellListener,
+    addSortedRowIdsListener,
     addWillFinishTransactionListener,
     addDidFinishTransactionListener,
     callListener,
@@ -2582,6 +2489,26 @@ const createStore = () => {
     getListenerStats,
     createStore,
   };
+  objForEach(
+    {
+      [TABLES]: [0, tablesListeners],
+      [TABLE_IDS]: [0, tableIdsListeners],
+      [TABLE]: [1, tableListeners],
+      [ROW_IDS]: [1, rowIdsListeners],
+      [ROW]: [2, rowListeners],
+      [CELL_IDS]: [2, cellIdsListeners],
+      [CELL]: [3, cellListeners],
+      InvalidCell: [3, invalidCellListeners],
+    },
+    ([argumentCount, idSetNode], listenable) => {
+      store[ADD + listenable + LISTENER] = (...args) =>
+        addListener(
+          args[argumentCount],
+          idSetNode[args[argumentCount + 1] ? 1 : 0],
+          argumentCount > 0 ? arraySlice(args, 0, argumentCount) : void 0,
+        );
+    },
+  );
   return objFreeze(store);
 };
 
@@ -2598,4 +2525,5 @@ export {
   createSessionPersister,
   createStore,
   defaultSorter,
+  id,
 };