tinybase 2.0.0-beta.2 → 2.0.0-beta.3

package/lib/debug/store.js

@@ -7,6 +7,15 @@ const NUMBER = getTypeOf(0);
 const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
+const LISTENER = 'Listener';
+const ADD = 'add';
+const TABLES = 'Tables';
+const TABLE_IDS = 'TableIds';
+const TABLE = 'Table';
+const ROW_IDS = 'RowIds';
+const ROW = 'Row';
+const CELL_IDS = 'CellIds';
+const CELL = 'Cell';
 
 const arrayHas = (array, value) => array.includes(value);
 const arrayEvery = (array, cb) => array.every(cb);
@@ -20,6 +29,7 @@ const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayFilter = (array, cb) => array.filter(cb);
+const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayPop = (array) => array.pop();
 
@@ -167,8 +177,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) => {
@@ -183,16 +191,12 @@ const getListenerFunctions = (getThing) => {
       };
       callWithIds();
     });
-  return [addListener, callListeners, delListener, hasListeners, callListener];
+  return [addListener, callListeners, delListener, callListener];
 };
 
 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 getCellType = (cell) => {
   const type = getTypeOf(cell);
@@ -247,22 +251,17 @@ 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) => {
@@ -444,49 +443,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,
     );
@@ -529,18 +491,9 @@ const createStore = () => {
             ),
         )
       : 0;
-  const callIdsListenersIfChanged = (listeners, changedIds, getIds, ids) => {
-    if (collSize(changedIds) > 1) {
-      callListeners(listeners[0], ids);
-      callListeners(listeners[1], ids);
-      return 1;
-    }
-    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;
     }
   };
@@ -549,10 +502,10 @@ const createStore = () => {
       sortedRowIdsListeners[mutator],
     );
     const emptyIdListeners =
-      pairCollIsEmpty(cellIdsListeners[mutator]) &&
-      pairCollIsEmpty(rowIdsListeners[mutator]) &&
+      collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(rowIdsListeners[mutator]) &&
       emptySortedRowIdListeners &&
-      pairCollIsEmpty(tableIdsListeners[mutator]);
+      collIsEmpty(tableIdsListeners[mutator]);
     const emptyOtherListeners =
       collIsEmpty(cellListeners[mutator]) &&
       collIsEmpty(rowListeners[mutator]) &&
@@ -570,23 +523,18 @@ 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,
+            ]),
           ),
         );
         const calledSortableTableIds = setNew();
         collForEach(changes[1], (changedIds, tableId) => {
           if (
-            callIdsListenersIfChanged(
-              rowIdsListeners[mutator],
-              changedIds,
-              getRowIds,
-              [tableId],
-            ) &&
+            callIdsListenersIfChanged(rowIdsListeners[mutator], changedIds, [
+              tableId,
+            ]) &&
             !emptySortedRowIdListeners
           ) {
             callListeners(sortedRowIdsListeners[mutator], [tableId, null]);
@@ -613,11 +561,7 @@ const createStore = () => {
             }
           });
         }
-        callIdsListenersIfChanged(
-          tableIdsListeners[mutator],
-          changes[0],
-          getTableIds,
-        );
+        callIdsListenersIfChanged(tableIdsListeners[mutator], changes[0]);
       }
       if (!emptyOtherListeners) {
         let tablesChanged;
@@ -665,7 +609,7 @@ const createStore = () => {
   const getTable = (tableId) =>
     mapToObj(mapGet(tablesMap, id(tableId)), mapToObj);
   const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, id(tableId)));
-  const getSortedRowIds = (tableId, cellId, descending) => {
+  const getSortedRowIds = (tableId, cellId, descending, offset = 0, limit) => {
     const cells = [];
     mapForEach(mapGet(tablesMap, id(tableId)), (rowId, row) =>
       arrayPush(cells, [
@@ -674,10 +618,14 @@ const createStore = () => {
       ]),
     );
     return arrayMap(
-      arraySort(
-        cells,
-        ([cell1], [cell2]) =>
-          defaultSorter(cell1, cell2) * (descending ? -1 : 1),
+      arraySlice(
+        arraySort(
+          cells,
+          ([cell1], [cell2]) =>
+            defaultSorter(cell1, cell2) * (descending ? -1 : 1),
+        ),
+        offset,
+        isUndefined(limit) ? limit : offset + limit,
       ),
       ([, rowId]) => rowId,
     );
@@ -922,67 +870,48 @@ const createStore = () => {
     );
   const forEachCell = (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) =>
-    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 addSortedRowIdsListener = (
     tableId,
     cellId,
     descending,
+    offset,
+    limit,
     listener,
     mutator,
   ) => {
-    let sortedRowIds = getSortedRowIds(tableId, cellId, descending);
+    let sortedRowIds = getSortedRowIds(
+      tableId,
+      cellId,
+      descending,
+      offset,
+      limit,
+    );
     return addListener(
       () => {
-        const newSortedRowIds = getSortedRowIds(tableId, cellId, descending);
+        const newSortedRowIds = getSortedRowIds(
+          tableId,
+          cellId,
+          descending,
+          offset,
+          limit,
+        );
         if (!arrayIsEqual(newSortedRowIds, sortedRowIds)) {
           sortedRowIds = newSortedRowIds;
-          listener(store, tableId, cellId, descending, sortedRowIds);
+          listener(
+            store,
+            tableId,
+            cellId,
+            descending,
+            offset,
+            limit,
+            sortedRowIds,
+          );
         }
       },
       sortedRowIdsListeners[mutator ? 1 : 0],
       [tableId, cellId],
     );
   };
-  const addRowListener = (tableId, rowId, listener, mutator) =>
-    addListener(listener, rowListeners[mutator ? 1 : 0], [tableId, rowId]);
-  const addCellIdsListener = (
-    tableId,
-    rowId,
-    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], [
-      tableId,
-      rowId,
-      cellId,
-    ]);
   const addWillFinishTransactionListener = (listener) =>
     addListener(listener, finishTransactionListeners[0]);
   const addDidFinishTransactionListener = (listener) =>
@@ -999,12 +928,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),
@@ -1043,15 +972,7 @@ const createStore = () => {
     forEachTable,
     forEachRow,
     forEachCell,
-    addTablesListener,
-    addTableIdsListener,
-    addTableListener,
-    addRowIdsListener,
     addSortedRowIdsListener,
-    addRowListener,
-    addCellIdsListener,
-    addCellListener,
-    addInvalidCellListener,
     addWillFinishTransactionListener,
     addDidFinishTransactionListener,
     callListener,
@@ -1059,6 +980,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);
 };