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

package/lib/debug/queries.js

@@ -1,17 +1,3 @@
-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 arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
-const arrayLength = (array) => array.length;
-const arrayIsEmpty = (array) => arrayLength(array) == 0;
-const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
-const arraySlice = (array, start, end) => array.slice(start, end);
-const arrayPush = (array, ...values) => array.push(...values);
-
 const getTypeOf = (thing) => typeof thing;
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
@@ -22,6 +8,25 @@ 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 TABLE = 'Table';
+const ROW_IDS = 'RowIds';
+const SORTED_ROW_IDS = 'SortedRowIds';
+const ROW = 'Row';
+const CELL_IDS = 'CellIds';
+const CELL = 'Cell';
+
+const arrayEvery = (array, cb) => array.every(cb);
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
+const arrayLength = (array) => array.length;
+const arrayIsEmpty = (array) => arrayLength(array) == 0;
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+const arraySlice = (array, start, end) => array.slice(start, end);
+const arrayPush = (array, ...values) => array.push(...values);
 
 const mathMax = Math.max;
 const mathMin = Math.min;
@@ -307,10 +312,9 @@ const getCreateFunction = (getFunction) => {
 };
 
 const object = Object;
-const objIds = object.keys;
 const objFreeze = object.freeze;
-
-const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
+const objForEach = (obj, cb) =>
+  arrayForEach(object.entries(obj), ([id, value]) => cb(value, id));
 
 const createQueries = getCreateFunction((store) => {
   const createStore = store.createStore;
@@ -329,25 +333,22 @@ const createQueries = getCreateFunction((store) => {
     addStoreListeners,
     delStoreListeners,
   ] = getDefinableFunctions(store, () => true, getUndefined);
-  const preStore1 = createStore();
-  const preStore2 = 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, preStore2, preStore1], (store2) =>
-      store2.delTable(queryId),
-    );
+    arrayForEach([resultStore, preStore], (store2) => store2.delTable(queryId));
   const synchronizeTransactions = (queryId, fromStore, toStore) =>
     addPreStoreListener(
       fromStore,
@@ -360,13 +361,11 @@ const createQueries = getCreateFunction((store) => {
   const setQueryDefinition = (queryId, tableId, build) => {
     setDefinition(queryId, tableId);
     cleanPreStores(queryId);
-    let offsetLimit;
     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]
@@ -432,17 +431,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;
@@ -454,95 +443,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), [
@@ -604,8 +509,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(
@@ -652,7 +557,7 @@ const createQueries = getCreateFunction((store) => {
                   ([, selectedRowIds, groupRowId]) => {
                     collDel(selectedRowIds, selectedRowId);
                     if (collIsEmpty(selectedRowIds)) {
-                      groupHavingStore.delRow(queryId, groupRowId);
+                      resultStore.delRow(queryId, groupRowId);
                       return 1;
                     }
                   },
@@ -682,7 +587,7 @@ const createQueries = getCreateFunction((store) => {
                     return [
                       mapNew(),
                       setNew(),
-                      groupHavingStore.addRow(queryId, groupRow, 1),
+                      resultStore.addRow(queryId, groupRow, 1),
                       groupRow,
                     ];
                   },
@@ -789,68 +694,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 getResultSortedRowIds = (queryId, cellId, descending) =>
-    resultStore.getSortedRowIds(queryId, cellId, descending);
-  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 addResultSortedRowIdsListener = (
-    queryId,
-    cellId,
-    descending,
-    listener,
-  ) =>
-    resultStore.addSortedRowIdsListener(
-      queryId,
-      cellId,
-      descending,
-      (_store, ...args) => listener(queries, ...args),
-    );
-  const addResultRowListener = (queryId, rowId, listener) =>
-    resultStore.addRowListener(queryId, rowId, (_store, ...args) =>
-      listener(queries, ...args),
-    );
-  const addResultCellIdsListener = (queryId, rowId, listener) =>
-    resultStore.addCellIdsListener(queryId, rowId, (_store, ...args) =>
-      listener(queries, ...args),
-    );
-  const addResultCellListener = (queryId, rowId, cellId, listener) =>
-    resultStore.addCellListener(queryId, rowId, cellId, (_store, ...args) =>
-      listener(queries, ...args),
-    );
   const delListener = (listenerId) => {
     resultStore.delListener(listenerId);
     return queries;
@@ -872,28 +724,34 @@ const createQueries = getCreateFunction((store) => {
     forEachQuery,
     hasQuery,
     getTableId,
-    getResultTable,
-    getResultRowIds,
-    getResultSortedRowIds,
-    getResultRow,
-    getResultCellIds,
-    getResultCell,
-    hasResultTable,
-    hasResultRow,
-    hasResultCell,
-    forEachResultTable,
-    forEachResultRow,
-    forEachResultCell,
-    addResultTableListener,
-    addResultRowIdsListener,
-    addResultSortedRowIdsListener,
-    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);
 });
 

package/lib/debug/relationships.js

@@ -2,7 +2,6 @@ const getTypeOf = (thing) => typeof thing;
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
 
-const arrayEvery = (array, cb) => array.every(cb);
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
@@ -257,8 +256,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) => {
@@ -273,7 +270,7 @@ const getListenerFunctions = (getThing) => {
       };
       callWithIds();
     });
-  return [addListener, callListeners, delListener, hasListeners, callListener];
+  return [addListener, callListeners, delListener, callListener];
 };
 
 const object = Object;