tinybase 1.3.5 → 2.0.0-beta.0

package/lib/debug/store.js

@@ -8,15 +8,17 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 
-const arrayPair = (value) => [value, value];
 const arrayHas = (array, value) => array.includes(value);
+const arrayEvery = (array, cb) => array.every(cb);
+const arrayIsEqual = (array1, array2) =>
+  arrayLength(array1) === arrayLength(array2) &&
+  arrayEvery(array1, (value1, index) => array2[index] === value1);
 const arrayForEach = (array, cb) => array.forEach(cb);
 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 arrayFromSecond = (ids) => ids.slice(1);
-const arrayPush = (array, value) => array.push(value);
+const arrayPush = (array, ...values) => array.push(...values);
 const arrayPop = (array) => array.pop();
 
 const jsonString = (obj) =>
@@ -47,7 +49,6 @@ const collSize = (coll) => coll.size;
 const collSize2 = collSizeN(collSize);
 const collSize3 = collSizeN(collSize2);
 const collSize4 = collSizeN(collSize3);
-const collPairSize = (pair, func = collSize) => func(pair[0]) + func(pair[1]);
 const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
 const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
 const collValues = (coll) => [...(coll?.values() ?? [])];
@@ -56,7 +57,6 @@ const collForEach = (coll, cb) => coll?.forEach(cb);
 const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
 const mapNew = (entries) => new Map(entries);
-const mapNewPair = (newFunction = mapNew) => [newFunction(), newFunction()];
 const mapKeys = (map) => [...(map?.keys() ?? [])];
 const mapGet = (map, key) => map?.get(key);
 const mapForEach = (map, cb) =>
@@ -86,6 +86,27 @@ const mapClone = (map, childMapper) => {
   return map2;
 };
 const mapClone2 = (map) => mapClone(map, mapClone);
+const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
+  ifNotUndefined(
+    (ensureLeaf ? mapEnsure : mapGet)(
+      node,
+      path[p],
+      p > arrayLength(path) - 2 ? ensureLeaf : mapNew,
+    ),
+    (nodeOrLeaf) => {
+      if (p > arrayLength(path) - 2) {
+        if (pruneLeaf?.(nodeOrLeaf)) {
+          mapSet(node, path[p]);
+        }
+        return nodeOrLeaf;
+      }
+      const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
+      if (collIsEmpty(nodeOrLeaf)) {
+        mapSet(node, path[p]);
+      }
+      return leaf;
+    },
+  );
 
 const object = Object;
 const objIds = object.keys;
@@ -103,64 +124,51 @@ const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
 const setNew = (entries) => new Set(entries);
 const setAdd = (set, value) => set?.add(value);
 
-const addDeepSet = (deepSet, value, ids) =>
-  arrayLength(ids) < 2
-    ? setAdd(
-        arrayIsEmpty(ids) ? deepSet : mapEnsure(deepSet, ids[0], setNew),
-        value,
-      )
-    : addDeepSet(
-        mapEnsure(deepSet, ids[0], mapNew),
-        value,
-        arrayFromSecond(ids),
-      );
-const forDeepSet = (valueDo) => {
-  const deep = (deepIdSet, arg, ...ids) =>
-    ifNotUndefined(deepIdSet, (deepIdSet2) =>
-      arrayIsEmpty(ids)
-        ? valueDo(deepIdSet2, arg)
-        : arrayForEach([ids[0], null], (id) =>
-            deep(mapGet(deepIdSet2, id), arg, ...arrayFromSecond(ids)),
-          ),
-    );
-  return deep;
+const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
+  const sets = [];
+  const deep = (set, p) =>
+    p == arrayLength(path)
+      ? arrayPush(sets, set)
+      : arrayForEach([path[p], null], (id) => deep(mapGet(set, id), p + 1));
+  deep(deepIdSet, 0);
+  return sets;
 };
 const getListenerFunctions = (getThing) => {
   let thing;
   let nextId = 0;
   const listenerPool = [];
   const allListeners = mapNew();
-  const addListener = (listener, deepSet, idOrNulls = []) => {
+  const addListener = (listener, idSetNode, idOrNulls) => {
     thing ??= getThing();
-    const id = arrayPop(listenerPool) ?? '' + nextId++;
-    mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
-    addDeepSet(deepSet, id, idOrNulls);
+    const id = arrayPop(listenerPool) ?? EMPTY_STRING + nextId++;
+    mapSet(allListeners, id, [listener, idSetNode, idOrNulls]);
+    setAdd(visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], setNew), id);
     return id;
   };
-  const callListeners = (deepSet, ids = [], ...extraArgs) =>
-    forDeepSet(collForEach)(
-      deepSet,
-      (id) =>
+  const callListeners = (idSetNode, ids, ...extraArgs) =>
+    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
+      collForEach(set, (id) =>
         ifNotUndefined(mapGet(allListeners, id), ([listener]) =>
-          listener(thing, ...ids, ...extraArgs),
+          listener(thing, ...(ids ?? []), ...extraArgs),
         ),
-      ...ids,
+      ),
     );
   const delListener = (id) =>
-    ifNotUndefined(
-      mapGet(allListeners, id),
-      ([, deepSet, idOrNulls]) => {
-        forDeepSet(collDel)(deepSet, id, ...idOrNulls);
-        mapSet(allListeners, id);
-        if (arrayLength(listenerPool) < 1e3) {
-          arrayPush(listenerPool, id);
-        }
-        return idOrNulls;
-      },
-      () => [],
-    );
+    ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
+      visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {
+        collDel(idSet, id);
+        return collIsEmpty(idSet) ? 1 : 0;
+      });
+      mapSet(allListeners, id);
+      if (arrayLength(listenerPool) < 1e3) {
+        arrayPush(listenerPool, id);
+      }
+      return idOrNulls;
+    });
+  const hasListeners = (idSetNode, ids) =>
+    !arrayEvery(getWildcardedLeaves(idSetNode, ids), isUndefined);
   const callListener = (id, idNullGetters, extraArgsGetter) =>
-    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls]) => {
+    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls = []]) => {
       const callWithIds = (...ids) => {
         const index = arrayLength(ids);
         index == arrayLength(idOrNulls)
@@ -173,7 +181,22 @@ const getListenerFunctions = (getThing) => {
       };
       callWithIds();
     });
-  return [addListener, callListeners, delListener, callListener];
+  return [addListener, callListeners, delListener, hasListeners, 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);
+  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+    ? type
+    : void 0;
 };
 
 const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
@@ -187,12 +210,6 @@ const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
   arrayForEach(idsToDelete, (id) => delId(map, id));
   return map;
 };
-const getCellType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
-    ? type
-    : void 0;
-};
 const validate = (obj, validateChild, onInvalidObj) => {
   if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
     onInvalidObj?.();
@@ -205,8 +222,8 @@ const validate = (obj, validateChild, onInvalidObj) => {
   });
   return !objIsEmpty(obj);
 };
-const idsChanged = (ids, id, added) =>
-  mapSet(ids, id, mapGet(ids, id) == -added ? void 0 : added);
+const idsChanged = (changedIds, id, added) =>
+  mapSet(changedIds, id, mapGet(changedIds, id) == -added ? void 0 : added);
 const createStore = () => {
   let hasSchema;
   let cellsTouched;
@@ -220,17 +237,22 @@ const createStore = () => {
   const schemaMap = mapNew();
   const schemaRowCache = mapNew();
   const tablesMap = mapNew();
-  const tablesListeners = mapNewPair(setNew);
-  const tableIdsListeners = mapNewPair(setNew);
-  const tableListeners = mapNewPair();
-  const rowIdsListeners = mapNewPair();
-  const rowListeners = mapNewPair();
-  const cellIdsListeners = mapNewPair();
-  const cellListeners = mapNewPair();
-  const invalidCellListeners = mapNewPair();
-  const finishTransactionListeners = mapNewPair(setNew);
-  const [addListener, callListeners, delListenerImpl, callListenerImpl] =
-    getListenerFunctions(() => store);
+  const tablesListeners = pairNewMap();
+  const tableIdsListeners = pair2NewMap();
+  const tableListeners = pairNewMap();
+  const rowIdsListeners = pair2NewMap();
+  const rowListeners = pairNewMap();
+  const cellIdsListeners = pair2NewMap();
+  const cellListeners = pairNewMap();
+  const invalidCellListeners = pairNewMap();
+  const finishTransactionListeners = pairNewMap();
+  const [
+    addListener,
+    callListeners,
+    delListenerImpl,
+    hasListeners,
+    callListenerImpl,
+  ] = getListenerFunctions(() => store);
   const validateSchema = (schema) =>
     validate(schema, (tableSchema) =>
       validate(tableSchema, (cellSchema) => {
@@ -381,7 +403,7 @@ const createStore = () => {
         ),
     );
   const getNewRowId = (tableMap) => {
-    const rowId = '' + nextRowId++;
+    const rowId = EMPTY_STRING + nextRowId++;
     if (!collHas(tableMap, rowId)) {
       return rowId;
     }
@@ -412,12 +434,49 @@ const createStore = () => {
     }
   };
   const tableIdsChanged = (tableId, added) =>
-    idsChanged(changedTableIds, tableId, added);
+    idsChanged(
+      collIsEmpty(changedTableIds)
+        ? mapSet(
+            changedTableIds,
+            null,
+            hasListeners(tableIdsListeners[0][1]) ||
+              hasListeners(tableIdsListeners[1][1])
+              ? getTableIds()
+              : 0,
+          )
+        : changedTableIds,
+      tableId,
+      added,
+    );
   const rowIdsChanged = (tableId, rowId, added) =>
-    idsChanged(mapEnsure(changedRowIds, tableId, mapNew), rowId, added);
+    idsChanged(
+      mapEnsure(changedRowIds, tableId, () =>
+        mapNew([
+          [
+            null,
+            hasListeners(rowIdsListeners[0][1], [tableId]) ||
+            hasListeners(rowIdsListeners[1][1], [tableId])
+              ? getRowIds(tableId)
+              : 0,
+          ],
+        ]),
+      ),
+      rowId,
+      added,
+    );
   const cellIdsChanged = (tableId, rowId, cellId, added) =>
     idsChanged(
-      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),
+      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, () =>
+        mapNew([
+          [
+            null,
+            hasListeners(cellIdsListeners[0][1], [tableId, rowId]) ||
+            hasListeners(cellIdsListeners[1][1], [tableId, rowId])
+              ? getCellIds(tableId, rowId)
+              : 0,
+          ],
+        ]),
+      ),
       cellId,
       added,
     );
@@ -442,7 +501,7 @@ const createStore = () => {
     ifNotUndefined(
       mapGet(mapGet(mapGet(changedCells, tableId), rowId), cellId),
       ([oldCell, newCell]) => [true, oldCell, newCell],
-      () => [false, ...arrayPair(getCell(tableId, rowId, cellId))],
+      () => [false, ...pairNew(getCell(tableId, rowId, cellId))],
     );
   const callInvalidCellListeners = (mutator) =>
     !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])
@@ -460,17 +519,29 @@ 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 callListenersForChanges = (mutator) => {
     const emptyIdListeners =
-      collIsEmpty(cellIdsListeners[mutator]) &&
-      collIsEmpty(rowIdsListeners[mutator]) &&
-      collIsEmpty(tableIdsListeners[mutator]);
+      pairCollIsEmpty(cellIdsListeners[mutator]) &&
+      pairCollIsEmpty(rowIdsListeners[mutator]) &&
+      pairCollIsEmpty(tableIdsListeners[mutator]);
     const emptyOtherListeners =
       collIsEmpty(cellListeners[mutator]) &&
       collIsEmpty(rowListeners[mutator]) &&
       collIsEmpty(tableListeners[mutator]) &&
       collIsEmpty(tablesListeners[mutator]);
-    if (!(emptyIdListeners && emptyOtherListeners)) {
+    if (!emptyIdListeners || !emptyOtherListeners) {
       const changes = mutator
         ? [
             mapClone(changedTableIds),
@@ -481,20 +552,28 @@ const createStore = () => {
         : [changedTableIds, changedRowIds, changedCellIds, changedCells];
       if (!emptyIdListeners) {
         collForEach(changes[2], (rowCellIds, tableId) =>
-          collForEach(rowCellIds, (changedIds, rowId) => {
-            if (!collIsEmpty(changedIds)) {
-              callListeners(cellIdsListeners[mutator], [tableId, rowId]);
-            }
-          }),
+          collForEach(rowCellIds, (changedIds, rowId) =>
+            callIdsListenersIfChanged(
+              cellIdsListeners[mutator],
+              changedIds,
+              getCellIds,
+              [tableId, rowId],
+            ),
+          ),
+        );
+        collForEach(changes[1], (changedIds, tableId) =>
+          callIdsListenersIfChanged(
+            rowIdsListeners[mutator],
+            changedIds,
+            getRowIds,
+            [tableId],
+          ),
+        );
+        callIdsListenersIfChanged(
+          tableIdsListeners[mutator],
+          changes[0],
+          getTableIds,
         );
-        collForEach(changes[1], (changedIds, tableId) => {
-          if (!collIsEmpty(changedIds)) {
-            callListeners(rowIdsListeners[mutator], [tableId]);
-          }
-        });
-        if (!collIsEmpty(changes[0])) {
-          callListeners(tableIdsListeners[mutator]);
-        }
       }
       if (!emptyOtherListeners) {
         let tablesChanged;
@@ -527,7 +606,7 @@ const createStore = () => {
           }
         });
         if (tablesChanged) {
-          callListeners(tablesListeners[mutator], [], getCellChange);
+          callListeners(tablesListeners[mutator], void 0, getCellChange);
         }
       }
     }
@@ -568,16 +647,15 @@ const createStore = () => {
         ? setValidRow(tableId, getOrCreateTable(tableId), rowId, row)
         : 0,
     );
-  const addRow = (tableId, row) =>
+  const addRow = (tableId, row, forceId) =>
     transaction(() => {
-      let rowId = void 0;
-      if (validateRow(tableId, rowId, row)) {
-        setValidRow(
-          tableId,
-          getOrCreateTable(tableId),
-          (rowId = getNewRowId(mapGet(tablesMap, tableId))),
-          row,
-        );
+      const isValidRow = validateRow(tableId, void 0, row);
+      const rowId =
+        isValidRow || forceId
+          ? getNewRowId(mapGet(tablesMap, tableId))
+          : void 0;
+      if (isValidRow) {
+        setValidRow(tableId, getOrCreateTable(tableId), rowId, row);
       }
       return rowId;
     });
@@ -709,12 +787,12 @@ const createStore = () => {
           transactions = -1;
           cellsTouched = false;
         }
-        callListeners(finishTransactionListeners[0], [], cellsTouched);
+        callListeners(finishTransactionListeners[0], void 0, cellsTouched);
         callInvalidCellListeners(0);
         if (cellsTouched) {
           callListenersForChanges(0);
         }
-        callListeners(finishTransactionListeners[1], [], cellsTouched);
+        callListeners(finishTransactionListeners[1], void 0, cellsTouched);
         transactions = 0;
         arrayForEach(
           [
@@ -748,16 +826,33 @@ const createStore = () => {
     mapForEach(mapGet(mapGet(tablesMap, tableId), rowId), cellCallback);
   const addTablesListener = (listener, mutator) =>
     addListener(listener, tablesListeners[mutator ? 1 : 0]);
-  const addTableIdsListener = (listener, mutator) =>
-    addListener(listener, tableIdsListeners[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, mutator) =>
-    addListener(listener, rowIdsListeners[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 = (tableId, rowId, listener, mutator) =>
-    addListener(listener, cellIdsListeners[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,
@@ -776,7 +871,7 @@ const createStore = () => {
     addListener(listener, finishTransactionListeners[1]);
   const callListener = (listenerId) => {
     callListenerImpl(listenerId, [getTableIds, getRowIds, getCellIds], (ids) =>
-      isUndefined(ids[2]) ? [] : arrayPair(getCell(...ids)),
+      isUndefined(ids[2]) ? [] : pairNew(getCell(...ids)),
     );
     return store;
   };
@@ -785,15 +880,15 @@ const createStore = () => {
     return store;
   };
   const getListenerStats = () => ({
-    tables: collPairSize(tablesListeners),
-    tableIds: collPairSize(tableIdsListeners),
-    table: collPairSize(tableListeners, collSize2),
-    rowIds: collPairSize(rowIdsListeners, collSize2),
-    row: collPairSize(rowListeners, collSize3),
-    cellIds: collPairSize(cellIdsListeners, collSize3),
-    cell: collPairSize(cellListeners, collSize4),
-    invalidCell: collPairSize(invalidCellListeners, collSize4),
-    transaction: collPairSize(finishTransactionListeners),
+    tables: pairCollSize2(tablesListeners),
+    tableIds: pair2CollSize2(tableIdsListeners),
+    table: pairCollSize2(tableListeners),
+    rowIds: pair2CollSize2(rowIdsListeners),
+    row: pairCollSize2(rowListeners, collSize3),
+    cellIds: pair2CollSize2(cellIdsListeners, collSize3),
+    cell: pairCollSize2(cellListeners, collSize4),
+    invalidCell: pairCollSize2(invalidCellListeners, collSize4),
+    transaction: pairCollSize2(finishTransactionListeners),
   });
   const store = {
     getTables,
@@ -841,6 +936,7 @@ const createStore = () => {
     callListener,
     delListener,
     getListenerStats,
+    createStore,
   };
   return objFreeze(store);
 };

package/lib/debug/tinybase.d.ts

@@ -9,5 +9,6 @@ export * from './common';
 export * from './indexes';
 export * from './metrics';
 export * from './persisters';
+export * from './queries';
 export * from './relationships';
 export * from './store';