tinybase 1.3.3 → 2.0.0-beta.0

package/lib/debug/metrics.js

@@ -7,13 +7,13 @@ const AVG = 'avg';
 const MIN = 'min';
 const MAX = 'max';
 
+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 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 mathMax = Math.max;
@@ -50,6 +50,96 @@ const mapEnsure = (map, key, getDefaultValue) => {
   }
   return mapGet(map, key);
 };
+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 numericAggregators = mapNew([
+  [
+    AVG,
+    [
+      (numbers, length) => arraySum(numbers) / length,
+      (metric, add, length) => metric + (add - metric) / (length + 1),
+      (metric, remove, length) => metric + (metric - remove) / (length - 1),
+      (metric, add, remove, length) => metric + (add - remove) / length,
+    ],
+  ],
+  [
+    MAX,
+    [
+      (numbers) => mathMax(...numbers),
+      (metric, add) => mathMax(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMax(add, metric),
+    ],
+  ],
+  [
+    MIN,
+    [
+      (numbers) => mathMin(...numbers),
+      (metric, add) => mathMin(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMin(add, metric),
+    ],
+  ],
+  [
+    SUM,
+    [
+      (numbers) => arraySum(numbers),
+      (metric, add) => metric + add,
+      (metric, remove) => metric - remove,
+      (metric, add, remove) => metric - remove + add,
+    ],
+  ],
+]);
+const getAggregateValue = (
+  aggregateValue,
+  oldLength,
+  newValues,
+  changedValues,
+  aggregators,
+  force = false,
+) => {
+  if (collIsEmpty(newValues)) {
+    return void 0;
+  }
+  const [aggregate, aggregateAdd, aggregateRemove, aggregateReplace] =
+    aggregators;
+  force ||= isUndefined(aggregateValue);
+  collForEach(changedValues, ([oldValue, newValue]) => {
+    if (!force) {
+      aggregateValue = isUndefined(oldValue)
+        ? aggregateAdd?.(aggregateValue, newValue, oldLength++)
+        : isUndefined(newValue)
+        ? aggregateRemove?.(aggregateValue, oldValue, oldLength--)
+        : aggregateReplace?.(aggregateValue, newValue, oldValue, oldLength);
+      force ||= isUndefined(aggregateValue);
+    }
+  });
+  return force
+    ? aggregate(collValues(newValues), collSize(newValues))
+    : aggregateValue;
+};
 
 const setNew = (entries) => new Set(entries);
 const setAdd = (set, value) => set?.add(value);
@@ -68,20 +158,46 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   const getTableId = (id) => mapGet(tableIds, id);
   const getThing = (id) => mapGet(things, id);
   const setThing = (id, thing) => mapSet(things, id, thing);
-  const removeStoreListeners = (id) =>
-    ifNotUndefined(mapGet(storeListenerIds, id), (listenerIds) => {
-      collForEach(listenerIds, store.delListener);
-      mapSet(storeListenerIds, id);
+  const addStoreListeners = (id, andCall, ...listenerIds) => {
+    const set = mapEnsure(storeListenerIds, id, setNew);
+    arrayForEach(
+      listenerIds,
+      (listenerId) =>
+        setAdd(set, listenerId) && andCall && store.callListener(listenerId),
+    );
+    return listenerIds;
+  };
+  const delStoreListeners = (id, ...listenerIds) =>
+    ifNotUndefined(mapGet(storeListenerIds, id), (allListenerIds) => {
+      arrayForEach(
+        arrayIsEmpty(listenerIds) ? collValues(allListenerIds) : listenerIds,
+        (listenerId) => {
+          store.delListener(listenerId);
+          collDel(allListenerIds, listenerId);
+        },
+      );
+      if (collIsEmpty(allListenerIds)) {
+        mapSet(storeListenerIds, id);
+      }
     });
-  const setDefinition = (id, tableId, onChanged, getRowValue, getSortKey) => {
-    const changedRowValues = mapNew();
-    const changedSortKeys = mapNew();
+  const setDefinition = (id, tableId) => {
     mapSet(tableIds, id, tableId);
     if (!collHas(things, id)) {
       mapSet(things, id, getDefaultThing());
       mapSet(allRowValues, id, mapNew());
       mapSet(allSortKeys, id, mapNew());
     }
+  };
+  const setDefinitionAndListen = (
+    id,
+    tableId,
+    onChanged,
+    getRowValue,
+    getSortKey,
+  ) => {
+    setDefinition(id, tableId);
+    const changedRowValues = mapNew();
+    const changedSortKeys = mapNew();
     const rowValues = mapGet(allRowValues, id);
     const sortKeys = mapGet(allSortKeys, id);
     const processRow = (rowId) => {
@@ -131,16 +247,14 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
       });
     }
     processTable(true);
-    removeStoreListeners(id);
-    mapSet(
-      storeListenerIds,
+    delStoreListeners(id);
+    addStoreListeners(
       id,
-      setNew([
-        store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
-          processRow(rowId),
-        ),
-        store.addTableListener(tableId, () => processTable()),
-      ]),
+      0,
+      store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
+        processRow(rowId),
+      ),
+      store.addTableListener(tableId, () => processTable()),
     );
   };
   const delDefinition = (id) => {
@@ -148,7 +262,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
     mapSet(things, id);
     mapSet(allRowValues, id);
     mapSet(allSortKeys, id);
-    removeStoreListeners(id);
+    delStoreListeners(id);
   };
   const destroy = () => mapForEach(storeListenerIds, delDefinition);
   return [
@@ -160,8 +274,11 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
     getThing,
     setThing,
     setDefinition,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
+    addStoreListeners,
+    delStoreListeners,
   ];
 };
 const getRowCellFunction = (getRowCell, defaultCellValue) =>
@@ -178,64 +295,51 @@ const getCreateFunction = (getFunction) => {
   };
 };
 
-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)
@@ -248,52 +352,12 @@ const getListenerFunctions = (getThing) => {
       };
       callWithIds();
     });
-  return [addListener, callListeners, delListener, callListener];
+  return [addListener, callListeners, delListener, hasListeners, callListener];
 };
 
 const object = Object;
 const objFreeze = object.freeze;
 
-const aggregators = mapNew([
-  [
-    AVG,
-    [
-      (numbers, length) => arraySum(numbers) / length,
-      (metric, add, length) => metric + (add - metric) / (length + 1),
-      (metric, remove, length) => metric + (metric - remove) / (length - 1),
-      (metric, add, remove, length) => metric + (add - remove) / length,
-    ],
-  ],
-  [
-    MAX,
-    [
-      (numbers) => mathMax(...numbers),
-      (metric, add) => mathMax(add, metric),
-      (metric, remove) => (remove == metric ? void 0 : metric),
-      (metric, add, remove) =>
-        remove == metric ? void 0 : mathMax(add, metric),
-    ],
-  ],
-  [
-    MIN,
-    [
-      (numbers) => mathMin(...numbers),
-      (metric, add) => mathMin(add, metric),
-      (metric, remove) => (remove == metric ? void 0 : metric),
-      (metric, add, remove) =>
-        remove == metric ? void 0 : mathMin(add, metric),
-    ],
-  ],
-  [
-    SUM,
-    [
-      (numbers) => arraySum(numbers),
-      (metric, add) => metric + add,
-      (metric, remove) => metric - remove,
-      (metric, add, remove) => metric - remove + add,
-    ],
-  ],
-]);
 const createMetrics = getCreateFunction((store) => {
   const metricListeners = mapNew();
   const [
@@ -304,7 +368,8 @@ const createMetrics = getCreateFunction((store) => {
     getTableId,
     getMetric,
     setMetric,
-    setDefinition,
+    ,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
   ] = getDefinableFunctions(store, getUndefined, (value) =>
@@ -328,38 +393,29 @@ const createMetrics = getCreateFunction((store) => {
     aggregateRemove,
     aggregateReplace,
   ) => {
-    const metricAggregators = isFunction(aggregate)
+    const aggregators = isFunction(aggregate)
       ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
-      : mapGet(aggregators, aggregate) ?? mapGet(aggregators, SUM);
-    setDefinition(
+      : mapGet(numericAggregators, aggregate) ??
+        mapGet(numericAggregators, SUM);
+    setDefinitionAndListen(
       metricId,
       tableId,
       (change, changedNumbers, _changedSortKeys, numbers, _sortKeys, force) => {
-        let newMetric = getMetric(metricId);
-        let length = collSize(numbers);
-        const [aggregate2, aggregateAdd2, aggregateRemove2, aggregateReplace2] =
-          metricAggregators;
-        force = force || isUndefined(newMetric);
-        collForEach(changedNumbers, ([oldNumber, newNumber]) => {
-          if (!force) {
-            newMetric = isUndefined(oldNumber)
-              ? aggregateAdd2?.(newMetric, newNumber, length++)
-              : isUndefined(newNumber)
-              ? aggregateRemove2?.(newMetric, oldNumber, length--)
-              : aggregateReplace2?.(newMetric, newNumber, oldNumber, length);
-          }
-          force = force || isUndefined(newMetric);
-        });
+        const oldMetric = getMetric(metricId);
+        const oldLength = collSize(numbers);
+        force ||= isUndefined(oldMetric);
         change();
-        if (collIsEmpty(numbers)) {
-          newMetric = void 0;
-        } else if (force) {
-          newMetric = aggregate2(collValues(numbers), collSize(numbers));
-        }
+        let newMetric = getAggregateValue(
+          oldMetric,
+          oldLength,
+          numbers,
+          changedNumbers,
+          aggregators,
+          force,
+        );
         if (!isFiniteNumber(newMetric)) {
           newMetric = void 0;
         }
-        const oldMetric = getMetric(metricId);
         if (newMetric != oldMetric) {
           setMetric(metricId, newMetric);
           callListeners(metricListeners, [metricId], newMetric, oldMetric);

package/lib/debug/persisters.js

@@ -1,5 +1,6 @@
 import {promises, watch} from 'fs';
 
+const EMPTY_STRING = '';
 const UTF8 = 'utf8';
 
 const isUndefined = (thing) => thing == void 0;
@@ -29,7 +30,7 @@ const createCustomPersister = (
           loads++;
         }
         const body = await getPersisted();
-        if (!isUndefined(body) && body != '') {
+        if (!isUndefined(body) && body != EMPTY_STRING) {
           store.setJson(body);
         } else {
           store.setTables(initialTables);