tinybase 0.9.3 → 1.0.2

package/lib/debug/indexes.js

@@ -1,390 +0,0 @@
-const getTypeOf = (thing) => typeof thing;
-const EMPTY_STRING = '';
-const STRING = getTypeOf(EMPTY_STRING);
-
-const arrayIsSorted = (array, sorter) =>
-  array.every(
-    (value, index) => index == 0 || sorter(array[index - 1], value) <= 0,
-  );
-const arraySort = (array, sorter) => array.sort(sorter);
-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 isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isString = (thing) => getTypeOf(thing) == STRING;
-
-const collSizeN = (collSizer) => (coll) =>
-  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
-const collSize = (coll) => coll.size;
-const collSize2 = collSizeN(collSize);
-const collSize3 = collSizeN(collSize2);
-const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
-const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
-const collValues = (coll) => [...(coll?.values() ?? [])];
-const collClear = (coll) => coll.clear();
-const collForEach = (coll, cb) => coll?.forEach(cb);
-const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
-
-const mapNew = (entries) => new Map(entries);
-const mapKeys = (map) => [...(map?.keys() ?? [])];
-const mapGet = (map, key) => 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?.set(key, value);
-const mapEnsure = (map, key, defaultValue, onWillAdd) => {
-  if (!collHas(map, key)) {
-    onWillAdd?.(defaultValue);
-    map.set(key, defaultValue);
-  }
-  return mapGet(map, key);
-};
-
-const setNew = (entries) => new Set(entries);
-const setAdd = (set, value) => set?.add(value);
-
-const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
-  const hasRow = store.hasRow;
-  const tableIds = mapNew();
-  const things = mapNew();
-  const allRowValues = mapNew();
-  const allSortKeys = mapNew();
-  const storeListenerIds = mapNew();
-  const getStore = () => store;
-  const getThingIds = () => mapKeys(tableIds);
-  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 setDefinition = (id, tableId, onChanged, getRowValue, getSortKey) => {
-    const changedRowValues = mapNew();
-    const changedSortKeys = mapNew();
-    mapSet(tableIds, id, tableId);
-    if (!collHas(things, id)) {
-      mapSet(things, id, getDefaultThing());
-      mapSet(allRowValues, id, mapNew());
-      mapSet(allSortKeys, id, 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) {
-        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);
-    removeStoreListeners(id);
-    mapSet(
-      storeListenerIds,
-      id,
-      setNew([
-        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);
-    removeStoreListeners(id);
-  };
-  const destroy = () => mapForEach(storeListenerIds, delDefinition);
-  return [
-    getStore,
-    getThingIds,
-    getTableId,
-    getThing,
-    setThing,
-    setDefinition,
-    delDefinition,
-    destroy,
-  ];
-};
-const getRowCellFunction = (getRowCell, defaultCellValue) =>
-  isString(getRowCell)
-    ? (getCell) => getCell(getRowCell)
-    : getRowCell ?? (() => defaultCellValue ?? EMPTY_STRING);
-const getCreateFunction = (getFunction) => {
-  const getFunctionsByStore = /* @__PURE__ */ new WeakMap();
-  return (store) => {
-    if (!getFunctionsByStore.has(store)) {
-      getFunctionsByStore.set(store, getFunction(store));
-    }
-    return getFunctionsByStore.get(store);
-  };
-};
-
-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 getListenerFunctions = (getThing) => {
-  let thing;
-  let nextId = 0;
-  const listenerPool = [];
-  const allListeners = mapNew();
-  const addListener = (listener, deepSet, idOrNulls = []) => {
-    thing ??= getThing();
-    const id = listenerPool.pop() ?? '' + nextId++;
-    mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
-    addDeepSet(deepSet, id, idOrNulls);
-    return id;
-  };
-  const callListeners = (deepSet, ids = [], ...extraArgs) =>
-    forDeepSet(collForEach)(
-      deepSet,
-      (id) =>
-        ifNotUndefined(mapGet(allListeners, id), ([listener]) =>
-          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) {
-          listenerPool.push(id);
-        }
-        return idOrNulls;
-      },
-      () => [],
-    );
-  const callListener = (id, idNullGetters, extraArgsGetter) =>
-    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls]) => {
-      const callWithIds = (...ids) => {
-        const index = arrayLength(ids);
-        index == arrayLength(idOrNulls)
-          ? listener(thing, ...ids, ...extraArgsGetter(ids))
-          : isUndefined(idOrNulls[index])
-          ? arrayForEach(idNullGetters[index](...ids), (id2) =>
-              callWithIds(...ids, id2),
-            )
-          : callWithIds(...ids, idOrNulls[index]);
-      };
-      callWithIds();
-    });
-  return [addListener, callListeners, delListener, callListener];
-};
-
-const object = Object;
-const objFreeze = object.freeze;
-
-const createIndexes = getCreateFunction((store) => {
-  const sliceIdsListeners = mapNew();
-  const sliceRowIdsListeners = mapNew();
-  const [
-    getStore,
-    getIndexIds,
-    getTableId,
-    getIndex,
-    setIndex,
-    setDefinition,
-    delDefinition,
-    destroy,
-  ] = getDefinableFunctions(store, mapNew, (value) =>
-    isUndefined(value) ? EMPTY_STRING : value + EMPTY_STRING,
-  );
-  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
-    () => indexes,
-  );
-  const setIndexDefinition = (
-    indexId,
-    tableId,
-    getSliceId,
-    getSortKey,
-    sliceIdSorter,
-    rowIdSorter = defaultSorter,
-  ) => {
-    const sliceIdArraySorter = isUndefined(sliceIdSorter)
-      ? void 0
-      : ([id1], [id2]) => sliceIdSorter(id1, id2);
-    setDefinition(
-      indexId,
-      tableId,
-      (change, changedSliceIds, changedSortKeys, sliceIds, sortKeys) => {
-        let sliceIdsChanged = 0;
-        const changedSlices = setNew();
-        const unsortedSlices = setNew();
-        const index = getIndex(indexId);
-        collForEach(changedSliceIds, ([oldSliceId, newSliceId], rowId) => {
-          if (!isUndefined(oldSliceId)) {
-            setAdd(changedSlices, oldSliceId);
-            ifNotUndefined(mapGet(index, oldSliceId), (oldSlice) => {
-              collDel(oldSlice, rowId);
-              if (collIsEmpty(oldSlice)) {
-                mapSet(index, oldSliceId);
-                sliceIdsChanged = 1;
-              }
-            });
-          }
-          if (!isUndefined(newSliceId)) {
-            setAdd(changedSlices, newSliceId);
-            if (!collHas(index, newSliceId)) {
-              mapSet(index, newSliceId, setNew());
-              sliceIdsChanged = 1;
-            }
-            setAdd(mapGet(index, newSliceId), rowId);
-            if (!isUndefined(getSortKey)) {
-              setAdd(unsortedSlices, newSliceId);
-            }
-          }
-        });
-        change();
-        mapForEach(changedSortKeys, (rowId) =>
-          ifNotUndefined(mapGet(sliceIds, rowId), (sliceId) =>
-            setAdd(unsortedSlices, sliceId),
-          ),
-        );
-        if (!collIsEmpty(sortKeys)) {
-          collForEach(unsortedSlices, (sliceId) => {
-            const rowIdArraySorter = (rowId1, rowId2) =>
-              rowIdSorter(
-                mapGet(sortKeys, rowId1),
-                mapGet(sortKeys, rowId2),
-                sliceId,
-              );
-            const sliceArray = [...mapGet(index, sliceId)];
-            if (!arrayIsSorted(sliceArray, rowIdArraySorter)) {
-              mapSet(
-                index,
-                sliceId,
-                setNew(arraySort(sliceArray, rowIdArraySorter)),
-              );
-              setAdd(changedSlices, sliceId);
-            }
-          });
-        }
-        if (sliceIdsChanged) {
-          if (!isUndefined(sliceIdArraySorter)) {
-            const indexArray = [...index];
-            if (!arrayIsSorted(indexArray, sliceIdArraySorter)) {
-              setIndex(
-                indexId,
-                mapNew(arraySort(indexArray, sliceIdArraySorter)),
-              );
-            }
-          }
-          callListeners(sliceIdsListeners, [indexId]);
-        }
-        collForEach(changedSlices, (sliceId) =>
-          callListeners(sliceRowIdsListeners, [indexId, sliceId]),
-        );
-      },
-      getRowCellFunction(getSliceId),
-      ifNotUndefined(getSortKey, getRowCellFunction),
-    );
-    return indexes;
-  };
-  const delIndexDefinition = (indexId) => {
-    delDefinition(indexId);
-    return indexes;
-  };
-  const getSliceIds = (indexId) => mapKeys(getIndex(indexId));
-  const getSliceRowIds = (indexId, sliceId) =>
-    collValues(mapGet(getIndex(indexId), sliceId));
-  const addSliceIdsListener = (indexId, listener) =>
-    addListener(listener, sliceIdsListeners, [indexId]);
-  const addSliceRowIdsListener = (indexId, sliceId, listener) =>
-    addListener(listener, sliceRowIdsListeners, [indexId, sliceId]);
-  const delListener = (listenerId) => {
-    delListenerImpl(listenerId);
-    return indexes;
-  };
-  const getListenerStats = () => ({
-    sliceIds: collSize2(sliceIdsListeners),
-    sliceRowIds: collSize3(sliceRowIdsListeners),
-  });
-  const indexes = {
-    setIndexDefinition,
-    delIndexDefinition,
-    getStore,
-    getIndexIds,
-    getTableId,
-    getSliceIds,
-    getSliceRowIds,
-    addSliceIdsListener,
-    addSliceRowIdsListener,
-    delListener,
-    destroy,
-    getListenerStats,
-  };
-  return objFreeze(indexes);
-});
-const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
-
-export {createIndexes, defaultSorter};