tinybase 6.0.0-beta.0 → 6.0.0-beta.2

package/cjs/es6/relationships/index.cjs

@@ -1,593 +0,0 @@
-'use strict';
-
-const getTypeOf = (thing) => typeof thing;
-const EMPTY_STRING = '';
-const STRING = getTypeOf(EMPTY_STRING);
-
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? (otherwise == null ? void 0 : otherwise()) : then(value);
-const isString = (thing) => getTypeOf(thing) == STRING;
-const isArray = (thing) => Array.isArray(thing);
-const size = (arrayOrString) => arrayOrString.length;
-const test = (regex, subject) => regex.test(subject);
-
-const arrayEvery = (array, cb) => array.every(cb);
-const arrayIsEqual = (array1, array2) =>
-  size(array1) === size(array2) &&
-  arrayEvery(array1, (value1, index) => array2[index] === value1);
-const arrayForEach = (array, cb) => array.forEach(cb);
-const arrayIsEmpty = (array) => size(array) == 0;
-const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
-const arrayPush = (array, ...values) => array.push(...values);
-const arrayShift = (array) => array.shift();
-
-const object = Object;
-const objFreeze = object.freeze;
-
-const collSizeN = (collSizer) => (coll) =>
-  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
-const collSize = (coll) => {
-  var _a;
-  return (_a = coll == null ? void 0 : coll.size) != null ? _a : 0;
-};
-const collSize2 = collSizeN(collSize);
-const collSize3 = collSizeN(collSize2);
-const collHas = (coll, keyOrValue) => {
-  var _a;
-  return (_a = coll == null ? void 0 : coll.has(keyOrValue)) != null
-    ? _a
-    : false;
-};
-const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
-const collValues = (coll) => {
-  var _a;
-  return [...((_a = coll == null ? void 0 : coll.values()) != null ? _a : [])];
-};
-const collClear = (coll) => coll.clear();
-const collForEach = (coll, cb) => (coll == null ? void 0 : coll.forEach(cb));
-const collDel = (coll, keyOrValue) =>
-  coll == null ? void 0 : coll.delete(keyOrValue);
-
-const mapNew = (entries) => new Map(entries);
-const mapKeys = (map) => {
-  var _a;
-  return [...((_a = map == null ? void 0 : map.keys()) != null ? _a : [])];
-};
-const mapGet = (map, key) => (map == null ? void 0 : map.get(key));
-const mapForEach = (map, cb) =>
-  collForEach(map, (value, key) => cb(key, value));
-const mapSet = (map, key, value) =>
-  isUndefined(value)
-    ? (collDel(map, key), map)
-    : map == null
-      ? void 0
-      : map.set(key, value);
-const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
-  } else {
-    hadExistingValue == null ? void 0 : hadExistingValue(mapGet(map, key));
-  }
-  return mapGet(map, key);
-};
-const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
-  ifNotUndefined(
-    (ensureLeaf ? mapEnsure : mapGet)(
-      node,
-      path[p],
-      p > size(path) - 2 ? ensureLeaf : mapNew,
-    ),
-    (nodeOrLeaf) => {
-      if (p > size(path) - 2) {
-        if (pruneLeaf == null ? void 0 : 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 = (entryOrEntries) =>
-  new Set(
-    isArray(entryOrEntries) || isUndefined(entryOrEntries)
-      ? entryOrEntries
-      : [entryOrEntries],
-  );
-const setAdd = (set, value) => (set == null ? void 0 : set.add(value));
-
-const getDefinableFunctions = (
-  store,
-  getDefaultThing,
-  validateRowValue,
-  addListener,
-  callListeners,
-) => {
-  const hasRow = store.hasRow;
-  const tableIds = mapNew();
-  const things = mapNew();
-  const thingIdListeners = mapNew();
-  const allRowValues = mapNew();
-  const allSortKeys = mapNew();
-  const storeListenerIds = mapNew();
-  const getStore = () => store;
-  const getThingIds = () => mapKeys(tableIds);
-  const forEachThing = (cb) => mapForEach(things, cb);
-  const hasThing = (id) => collHas(things, id);
-  const getTableId = (id) => mapGet(tableIds, id);
-  const getThing = (id) => mapGet(things, id);
-  const setThing = (id, thing) => mapSet(things, id, thing);
-  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) => {
-    mapSet(tableIds, id, tableId);
-    if (!collHas(things, id)) {
-      mapSet(things, id, getDefaultThing());
-      mapSet(allRowValues, id, mapNew());
-      mapSet(allSortKeys, id, mapNew());
-      callListeners(thingIdListeners);
-    }
-  };
-  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) => {
-      const getCell = (cellId) => store.getCell(tableId, rowId, cellId);
-      const oldRowValue = mapGet(rowValues, rowId);
-      const newRowValue = hasRow(tableId, rowId)
-        ? validateRowValue(getRowValue(getCell, rowId))
-        : void 0;
-      if (
-        !(
-          oldRowValue === newRowValue ||
-          (isArray(oldRowValue) &&
-            isArray(newRowValue) &&
-            arrayIsEqual(oldRowValue, newRowValue))
-        )
-      ) {
-        mapSet(changedRowValues, rowId, [oldRowValue, newRowValue]);
-      }
-      if (!isUndefined(getSortKey)) {
-        const oldSortKey = mapGet(sortKeys, rowId);
-        const newSortKey = hasRow(tableId, rowId)
-          ? getSortKey(getCell, rowId)
-          : void 0;
-        if (oldSortKey != newSortKey) {
-          mapSet(changedSortKeys, rowId, newSortKey);
-        }
-      }
-    };
-    const processTable = (force) => {
-      onChanged(
-        () => {
-          collForEach(changedRowValues, ([, newRowValue], rowId) =>
-            mapSet(rowValues, rowId, newRowValue),
-          );
-          collForEach(changedSortKeys, (newSortKey, rowId) =>
-            mapSet(sortKeys, rowId, newSortKey),
-          );
-        },
-        changedRowValues,
-        changedSortKeys,
-        rowValues,
-        sortKeys,
-        force,
-      );
-      collClear(changedRowValues);
-      collClear(changedSortKeys);
-    };
-    mapForEach(rowValues, processRow);
-    if (store.hasTable(tableId)) {
-      arrayForEach(store.getRowIds(tableId), (rowId) => {
-        if (!collHas(rowValues, rowId)) {
-          processRow(rowId);
-        }
-      });
-    }
-    processTable(true);
-    delStoreListeners(id);
-    addStoreListeners(
-      id,
-      0,
-      store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
-        processRow(rowId),
-      ),
-      store.addTableListener(tableId, () => processTable()),
-    );
-  };
-  const delDefinition = (id) => {
-    mapSet(tableIds, id);
-    mapSet(things, id);
-    mapSet(allRowValues, id);
-    mapSet(allSortKeys, id);
-    delStoreListeners(id);
-    callListeners(thingIdListeners);
-  };
-  const addThingIdsListener = (listener) =>
-    addListener(listener, thingIdListeners);
-  const destroy = () => mapForEach(storeListenerIds, delDefinition);
-  return [
-    getStore,
-    getThingIds,
-    forEachThing,
-    hasThing,
-    getTableId,
-    getThing,
-    setThing,
-    setDefinition,
-    setDefinitionAndListen,
-    delDefinition,
-    addThingIdsListener,
-    destroy,
-    addStoreListeners,
-    delStoreListeners,
-  ];
-};
-const getRowCellFunction = (getRowCell, defaultCellValue) =>
-  isString(getRowCell)
-    ? (getCell) => getCell(getRowCell)
-    : getRowCell != null
-      ? getRowCell
-      : () => (defaultCellValue != null ? defaultCellValue : EMPTY_STRING);
-const getCreateFunction = (getFunction, initFunction) => {
-  const thingsByStore = /* @__PURE__ */ new WeakMap();
-  return (store) => {
-    if (!thingsByStore.has(store)) {
-      thingsByStore.set(store, getFunction(store));
-    }
-    const thing = thingsByStore.get(store);
-    return thing;
-  };
-};
-
-const INTEGER = /^\d+$/;
-const getPoolFunctions = () => {
-  const pool = [];
-  let nextId = 0;
-  return [
-    (reuse) => {
-      var _a;
-      return (_a = reuse ? arrayShift(pool) : null) != null
-        ? _a
-        : EMPTY_STRING + nextId++;
-    },
-    (id) => {
-      if (test(INTEGER, id) && size(pool) < 1e3) {
-        arrayPush(pool, id);
-      }
-    },
-  ];
-};
-
-const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
-  const leaves = [];
-  const deep = (node, p) =>
-    p == size(path)
-      ? arrayPush(leaves, node)
-      : path[p] === null
-        ? collForEach(node, (node2) => deep(node2, p + 1))
-        : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
-  deep(deepIdSet, 0);
-  return leaves;
-};
-const getListenerFunctions = (getThing) => {
-  let thing;
-  const [getId, releaseId] = getPoolFunctions();
-  const allListeners = mapNew();
-  const addListener = (
-    listener,
-    idSetNode,
-    path,
-    pathGetters = [],
-    extraArgsGetter = () => [],
-  ) => {
-    thing != null ? thing : (thing = getThing());
-    const id = getId(1);
-    mapSet(allListeners, id, [
-      listener,
-      idSetNode,
-      path,
-      pathGetters,
-      extraArgsGetter,
-    ]);
-    setAdd(
-      visitTree(idSetNode, path != null ? path : [EMPTY_STRING], setNew),
-      id,
-    );
-    return id;
-  };
-  const callListeners = (idSetNode, ids, ...extraArgs) =>
-    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
-      collForEach(set, (id) =>
-        mapGet(allListeners, id)[0](
-          thing,
-          ...(ids != null ? ids : []),
-          ...extraArgs,
-        ),
-      ),
-    );
-  const delListener = (id) =>
-    ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
-      visitTree(
-        idSetNode,
-        idOrNulls != null ? idOrNulls : [EMPTY_STRING],
-        void 0,
-        (idSet) => {
-          collDel(idSet, id);
-          return collIsEmpty(idSet) ? 1 : 0;
-        },
-      );
-      mapSet(allListeners, id);
-      releaseId(id);
-      return idOrNulls;
-    });
-  const callListener = (id) =>
-    ifNotUndefined(
-      mapGet(allListeners, id),
-      ([listener, , path = [], pathGetters, extraArgsGetter]) => {
-        const callWithIds = (...ids) => {
-          var _a, _b;
-          const index = size(ids);
-          if (index == size(path)) {
-            listener(thing, ...ids, ...extraArgsGetter(ids));
-          } else if (isUndefined(path[index])) {
-            arrayForEach(
-              (_b =
-                (_a = pathGetters[index]) == null
-                  ? void 0
-                  : _a.call(pathGetters, ...ids)) != null
-                ? _b
-                : [],
-              (id2) => callWithIds(...ids, id2),
-            );
-          } else {
-            callWithIds(...ids, path[index]);
-          }
-        };
-        callWithIds();
-      },
-    );
-  return [addListener, callListeners, delListener, callListener];
-};
-
-const createRelationships = getCreateFunction((store) => {
-  const remoteTableIds = mapNew();
-  const remoteRowIdListeners = mapNew();
-  const localRowIdsListeners = mapNew();
-  const linkedRowIdsListeners = mapNew();
-  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
-    () => relationships,
-  );
-  const [
-    getStore,
-    getRelationshipIds,
-    forEachRelationshipImpl,
-    hasRelationship,
-    getLocalTableId,
-    getRelationship,
-    ,
-    ,
-    setDefinitionAndListen,
-    delDefinition,
-    addRelationshipIdsListener,
-    destroy,
-  ] = getDefinableFunctions(
-    store,
-    () => [mapNew(), mapNew(), mapNew(), mapNew()],
-    (value) => (isUndefined(value) ? void 0 : value + EMPTY_STRING),
-    addListener,
-    callListeners,
-  );
-  const getLinkedRowIdsCache = (relationshipId, firstRowId, skipCache) =>
-    ifNotUndefined(
-      getRelationship(relationshipId),
-      ([remoteRows, , linkedRowsCache]) => {
-        if (!collHas(linkedRowsCache, firstRowId)) {
-          const linkedRows = setNew();
-          if (
-            getLocalTableId(relationshipId) != getRemoteTableId(relationshipId)
-          ) {
-            setAdd(linkedRows, firstRowId);
-          } else {
-            let rowId = firstRowId;
-            while (!isUndefined(rowId) && !collHas(linkedRows, rowId)) {
-              setAdd(linkedRows, rowId);
-              rowId = mapGet(remoteRows, rowId);
-            }
-          }
-          if (skipCache) {
-            return linkedRows;
-          }
-          mapSet(linkedRowsCache, firstRowId, linkedRows);
-        }
-        return mapGet(linkedRowsCache, firstRowId);
-      },
-    );
-  const delLinkedRowIdsCache = (relationshipId, firstRowId) =>
-    ifNotUndefined(getRelationship(relationshipId), ([, , linkedRowsCache]) =>
-      mapSet(linkedRowsCache, firstRowId),
-    );
-  const setRelationshipDefinition = (
-    relationshipId,
-    localTableId,
-    remoteTableId,
-    getRemoteRowId2,
-  ) => {
-    mapSet(remoteTableIds, relationshipId, remoteTableId);
-    setDefinitionAndListen(
-      relationshipId,
-      localTableId,
-      (change, changedRemoteRowIds) => {
-        const changedLocalRows = setNew();
-        const changedRemoteRows = setNew();
-        const changedLinkedRows = setNew();
-        const [localRows, remoteRows] = getRelationship(relationshipId);
-        collForEach(
-          changedRemoteRowIds,
-          ([oldRemoteRowId, newRemoteRowId], localRowId) => {
-            if (!isUndefined(oldRemoteRowId)) {
-              setAdd(changedRemoteRows, oldRemoteRowId);
-              ifNotUndefined(
-                mapGet(remoteRows, oldRemoteRowId),
-                (oldRemoteRow) => {
-                  collDel(oldRemoteRow, localRowId);
-                  if (collIsEmpty(oldRemoteRow)) {
-                    mapSet(remoteRows, oldRemoteRowId);
-                  }
-                },
-              );
-            }
-            if (!isUndefined(newRemoteRowId)) {
-              setAdd(changedRemoteRows, newRemoteRowId);
-              if (!collHas(remoteRows, newRemoteRowId)) {
-                mapSet(remoteRows, newRemoteRowId, setNew());
-              }
-              setAdd(mapGet(remoteRows, newRemoteRowId), localRowId);
-            }
-            setAdd(changedLocalRows, localRowId);
-            mapSet(localRows, localRowId, newRemoteRowId);
-            mapForEach(
-              mapGet(linkedRowIdsListeners, relationshipId),
-              (firstRowId) => {
-                if (
-                  collHas(
-                    getLinkedRowIdsCache(relationshipId, firstRowId),
-                    localRowId,
-                  )
-                ) {
-                  setAdd(changedLinkedRows, firstRowId);
-                }
-              },
-            );
-          },
-        );
-        change();
-        collForEach(changedLocalRows, (localRowId) =>
-          callListeners(remoteRowIdListeners, [relationshipId, localRowId]),
-        );
-        collForEach(changedRemoteRows, (remoteRowId) =>
-          callListeners(localRowIdsListeners, [relationshipId, remoteRowId]),
-        );
-        collForEach(changedLinkedRows, (firstRowId) => {
-          delLinkedRowIdsCache(relationshipId, firstRowId);
-          callListeners(linkedRowIdsListeners, [relationshipId, firstRowId]);
-        });
-      },
-      getRowCellFunction(getRemoteRowId2),
-    );
-    return relationships;
-  };
-  const forEachRelationship = (relationshipCallback) =>
-    forEachRelationshipImpl((relationshipId) =>
-      relationshipCallback(relationshipId, (rowCallback) =>
-        store.forEachRow(getLocalTableId(relationshipId), rowCallback),
-      ),
-    );
-  const delRelationshipDefinition = (relationshipId) => {
-    mapSet(remoteTableIds, relationshipId);
-    delDefinition(relationshipId);
-    return relationships;
-  };
-  const getRemoteTableId = (relationshipId) =>
-    mapGet(remoteTableIds, relationshipId);
-  const getRemoteRowId = (relationshipId, localRowId) => {
-    var _a;
-    return mapGet(
-      (_a = getRelationship(relationshipId)) == null ? void 0 : _a[0],
-      localRowId,
-    );
-  };
-  const getLocalRowIds = (relationshipId, remoteRowId) => {
-    var _a;
-    return collValues(
-      mapGet(
-        (_a = getRelationship(relationshipId)) == null ? void 0 : _a[1],
-        remoteRowId,
-      ),
-    );
-  };
-  const getLinkedRowIds = (relationshipId, firstRowId) =>
-    isUndefined(getRelationship(relationshipId))
-      ? [firstRowId]
-      : collValues(getLinkedRowIdsCache(relationshipId, firstRowId, true));
-  const addRemoteRowIdListener = (relationshipId, localRowId, listener) =>
-    addListener(listener, remoteRowIdListeners, [relationshipId, localRowId]);
-  const addLocalRowIdsListener = (relationshipId, remoteRowId, listener) =>
-    addListener(listener, localRowIdsListeners, [relationshipId, remoteRowId]);
-  const addLinkedRowIdsListener = (relationshipId, firstRowId, listener) => {
-    getLinkedRowIdsCache(relationshipId, firstRowId);
-    return addListener(listener, linkedRowIdsListeners, [
-      relationshipId,
-      firstRowId,
-    ]);
-  };
-  const delListener = (listenerId) => {
-    var _a;
-    delLinkedRowIdsCache(
-      ...((_a = delListenerImpl(listenerId)) != null ? _a : []),
-    );
-    return relationships;
-  };
-  const getListenerStats = () => ({
-    remoteRowId: collSize3(remoteRowIdListeners),
-    localRowIds: collSize3(localRowIdsListeners),
-    linkedRowIds: collSize3(linkedRowIdsListeners),
-  });
-  const relationships = {
-    setRelationshipDefinition,
-    delRelationshipDefinition,
-    getStore,
-    getRelationshipIds,
-    forEachRelationship,
-    hasRelationship,
-    getLocalTableId,
-    getRemoteTableId,
-    getRemoteRowId,
-    getLocalRowIds,
-    getLinkedRowIds,
-    addRelationshipIdsListener,
-    addRemoteRowIdListener,
-    addLocalRowIdsListener,
-    addLinkedRowIdsListener,
-    delListener,
-    destroy,
-    getListenerStats,
-  };
-  return objFreeze(relationships);
-});
-
-exports.createRelationships = createRelationships;