tinybase 2.0.0-beta.1 → 2.0.0-beta.2

package/lib/debug/store.js

@@ -13,7 +13,9 @@ const arrayEvery = (array, cb) => array.every(cb);
 const arrayIsEqual = (array1, array2) =>
   arrayLength(array1) === arrayLength(array2) &&
   arrayEvery(array1, (value1, index) => array2[index] === value1);
+const arraySort = (array, sorter) => array.sort(sorter);
 const arrayForEach = (array, cb) => array.forEach(cb);
+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);
@@ -65,7 +67,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);
 };
@@ -125,32 +127,32 @@ const setNew = (entries) => new Set(entries);
 const setAdd = (set, value) => set?.add(value);
 
 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) =>
@@ -198,16 +200,23 @@ const getCellType = (cell) => {
     ? type
     : void 0;
 };
+const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
+  isUndefined(cell)
+    ? store.delCell(tableId, rowId, cellId, true)
+    : store.setCell(tableId, rowId, cellId, cell);
+
+const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
+const id = (key) => EMPTY_STRING + key;
 
 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) => {
@@ -215,15 +224,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;
@@ -241,6 +250,7 @@ const createStore = () => {
   const tableIdsListeners = pair2NewMap();
   const tableListeners = pairNewMap();
   const rowIdsListeners = pair2NewMap();
+  const sortedRowIdsListeners = pairNewMap();
   const rowListeners = pairNewMap();
   const cellIdsListeners = pair2NewMap();
   const cellListeners = pairNewMap();
@@ -257,7 +267,7 @@ const createStore = () => {
     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;
         }
@@ -523,18 +533,25 @@ const createStore = () => {
     if (collSize(changedIds) > 1) {
       callListeners(listeners[0], ids);
       callListeners(listeners[1], ids);
-    } else if (
+      return 1;
+    }
+    if (
       !collIsEmpty(changedIds) &&
       mapGet(changedIds, null) != 0 &&
       !arrayIsEqual(mapGet(changedIds, null), getIds(...(ids ?? [])))
     ) {
       callListeners(listeners[1], ids);
+      return 1;
     }
   };
   const callListenersForChanges = (mutator) => {
+    const emptySortedRowIdListeners = collIsEmpty(
+      sortedRowIdsListeners[mutator],
+    );
     const emptyIdListeners =
       pairCollIsEmpty(cellIdsListeners[mutator]) &&
       pairCollIsEmpty(rowIdsListeners[mutator]) &&
+      emptySortedRowIdListeners &&
       pairCollIsEmpty(tableIdsListeners[mutator]);
     const emptyOtherListeners =
       collIsEmpty(cellListeners[mutator]) &&
@@ -561,14 +578,41 @@ const createStore = () => {
             ),
           ),
         );
-        collForEach(changes[1], (changedIds, tableId) =>
-          callIdsListenersIfChanged(
-            rowIdsListeners[mutator],
-            changedIds,
-            getRowIds,
-            [tableId],
-          ),
-        );
+        const calledSortableTableIds = setNew();
+        collForEach(changes[1], (changedIds, tableId) => {
+          if (
+            callIdsListenersIfChanged(
+              rowIdsListeners[mutator],
+              changedIds,
+              getRowIds,
+              [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],
@@ -611,26 +655,45 @@ 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) => {
+    const cells = [];
+    mapForEach(mapGet(tablesMap, id(tableId)), (rowId, row) =>
+      arrayPush(cells, [
+        isUndefined(cellId) ? rowId : mapGet(row, id(cellId)),
+        rowId,
+      ]),
+    );
+    return arrayMap(
+      arraySort(
+        cells,
+        ([cell1], [cell2]) =>
+          defaultSorter(cell1, cell2) * (descending ? -1 : 1),
+      ),
+      ([, 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) =>
@@ -638,17 +701,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
@@ -660,32 +734,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 {
@@ -706,24 +788,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(() => {
@@ -778,9 +878,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),
               ),
             ),
           );
@@ -819,11 +917,11 @@ 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);
+    mapForEach(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), cellCallback);
   const addTablesListener = (listener, mutator) =>
     addListener(listener, tablesListeners[mutator ? 1 : 0]);
   const addTableIdsListener = (listener, trackReorder, mutator) =>
@@ -839,6 +937,26 @@ const createStore = () => {
       rowIdsListeners[mutator ? 1 : 0][trackReorder ? 1 : 0],
       [tableId],
     );
+  const addSortedRowIdsListener = (
+    tableId,
+    cellId,
+    descending,
+    listener,
+    mutator,
+  ) => {
+    let sortedRowIds = getSortedRowIds(tableId, cellId, descending);
+    return addListener(
+      () => {
+        const newSortedRowIds = getSortedRowIds(tableId, cellId, descending);
+        if (!arrayIsEqual(newSortedRowIds, sortedRowIds)) {
+          sortedRowIds = newSortedRowIds;
+          listener(store, tableId, cellId, descending, sortedRowIds);
+        }
+      },
+      sortedRowIdsListeners[mutator ? 1 : 0],
+      [tableId, cellId],
+    );
+  };
   const addRowListener = (tableId, rowId, listener, mutator) =>
     addListener(listener, rowListeners[mutator ? 1 : 0], [tableId, rowId]);
   const addCellIdsListener = (
@@ -884,6 +1002,7 @@ const createStore = () => {
     tableIds: pair2CollSize2(tableIdsListeners),
     table: pairCollSize2(tableListeners),
     rowIds: pair2CollSize2(rowIdsListeners),
+    sortedRowIds: pairCollSize2(sortedRowIdsListeners),
     row: pairCollSize2(rowListeners, collSize3),
     cellIds: pair2CollSize2(cellIdsListeners, collSize3),
     cell: pairCollSize2(cellListeners, collSize4),
@@ -895,6 +1014,7 @@ const createStore = () => {
     getTableIds,
     getTable,
     getRowIds,
+    getSortedRowIds,
     getRow,
     getCellIds,
     getCell,
@@ -927,6 +1047,7 @@ const createStore = () => {
     addTableIdsListener,
     addTableListener,
     addRowIdsListener,
+    addSortedRowIdsListener,
     addRowListener,
     addCellIdsListener,
     addCellListener,