tinybase 1.3.5 → 2.0.0-beta.0

package/lib/debug/relationships.d.ts

@@ -190,6 +190,7 @@ export type RelationshipsListenerStats = {
  *   });
  *
  * const relationships = createRelationships(store);
+ *
  * // A local/remote table relationship:
  * relationships.setRelationshipDefinition(
  *   'petSpecies', //  relationshipId
@@ -197,6 +198,11 @@ export type RelationshipsListenerStats = {
  *   'species', //     remoteTableId to link to
  *   'species', //     cellId containing remote key
  * );
+ * console.log(relationships.getRemoteRowId('petSpecies', 'fido'));
+ * // -> 'dog'
+ * console.log(relationships.getLocalRowIds('petSpecies', 'dog'));
+ * // -> ['fido', 'cujo']
+ *
  * // A linked list relationship:
  * relationships.setRelationshipDefinition(
  *   'petSequence', // relationshipId
@@ -204,11 +210,6 @@ export type RelationshipsListenerStats = {
  *   'pets', //        the same remoteTableId to link within
  *   'next', //        cellId containing link key
  * );
- *
- * console.log(relationships.getRemoteRowId('petSpecies', 'fido'));
- * // -> 'dog'
- * console.log(relationships.getLocalRowIds('petSpecies', 'dog'));
- * // -> ['fido', 'cujo']
  * console.log(relationships.getLinkedRowIds('petSequence', 'fido'));
  * // -> ['fido', 'felix', 'cujo']
  *

package/lib/debug/relationships.js

@@ -2,12 +2,12 @@ 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;
 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 isUndefined = (thing) => thing == void 0;
@@ -40,6 +40,27 @@ 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 setNew = (entries) => new Set(entries);
 const setAdd = (set, value) => set?.add(value);
@@ -58,20 +79,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) => {
@@ -121,16 +168,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) => {
@@ -138,7 +183,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 [
@@ -150,8 +195,11 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
     getThing,
     setThing,
     setDefinition,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
+    addStoreListeners,
+    delStoreListeners,
   ];
 };
 const getRowCellFunction = (getRowCell, defaultCellValue) =>
@@ -168,64 +216,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)
@@ -238,7 +273,7 @@ const getListenerFunctions = (getThing) => {
       };
       callWithIds();
     });
-  return [addListener, callListeners, delListener, callListener];
+  return [addListener, callListeners, delListener, hasListeners, callListener];
 };
 
 const object = Object;
@@ -257,7 +292,8 @@ const createRelationships = getCreateFunction((store) => {
     getLocalTableId,
     getRelationship,
     ,
-    setDefinition,
+    ,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
   ] = getDefinableFunctions(
@@ -304,7 +340,7 @@ const createRelationships = getCreateFunction((store) => {
     getRemoteRowId2,
   ) => {
     mapSet(remoteTableIds, relationshipId, remoteTableId);
-    setDefinition(
+    setDefinitionAndListen(
       relationshipId,
       localTableId,
       (change, changedRemoteRowIds) => {