tinybase 0.0.0 → 0.9.0

package/lib/debug/checkpoints.js

@@ -0,0 +1,326 @@
+const arrayHas = (array, value) => array.includes(value);
+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 arrayClear = (array, to) => array.splice(0, to);
+
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+
+const collSizeN = (collSizer) => (coll) =>
+  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
+const collSize = (coll) => coll.size;
+const collSize2 = collSizeN(collSize);
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapGet = (map, key) => map?.get(key);
+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 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 ?? (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 createCheckpoints = getCreateFunction((store) => {
+  let backwardIdsSize = 100;
+  let currentId;
+  let delta = mapNew();
+  let listening = 1;
+  let nextCheckpointId;
+  let checkpointsChanged;
+  const checkpointIdsListeners = setNew();
+  const checkpointListeners = mapNew();
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => checkpoints,
+  );
+  const deltas = mapNew();
+  const labels = mapNew();
+  const backwardIds = [];
+  const forwardIds = [];
+  const updateStore = (oldOrNew, checkpointId) => {
+    listening = 0;
+    store.transaction(() =>
+      collForEach(mapGet(deltas, checkpointId), (table, tableId) =>
+        collForEach(table, (row, rowId) =>
+          collForEach(row, (oldNew, cellId) =>
+            isUndefined(oldNew[oldOrNew])
+              ? store.delCell(tableId, rowId, cellId, true)
+              : store.setCell(tableId, rowId, cellId, oldNew[oldOrNew]),
+          ),
+        ),
+      ),
+    );
+    listening = 1;
+  };
+  const clearCheckpointId = (checkpointId) => {
+    mapSet(deltas, checkpointId);
+    mapSet(labels, checkpointId);
+    callListeners(checkpointListeners, [checkpointId]);
+  };
+  const clearCheckpointIds = (checkpointIds, to) =>
+    arrayForEach(
+      arrayClear(checkpointIds, to ?? arrayLength(checkpointIds)),
+      clearCheckpointId,
+    );
+  const trimBackwardsIds = () =>
+    clearCheckpointIds(backwardIds, arrayLength(backwardIds) - backwardIdsSize);
+  const listenerId = store.addCellListener(
+    null,
+    null,
+    null,
+    (_store, tableId, rowId, cellId, newCell, oldCell) => {
+      if (listening) {
+        ifNotUndefined(currentId, () => {
+          backwardIds.push(currentId);
+          trimBackwardsIds();
+          clearCheckpointIds(forwardIds);
+          currentId = void 0;
+          checkpointsChanged = 1;
+        });
+        const table = mapEnsure(delta, tableId, mapNew());
+        const row = mapEnsure(table, rowId, mapNew());
+        const oldNew = mapEnsure(
+          row,
+          cellId,
+          [void 0, void 0],
+          (addOldNew) => (addOldNew[0] = oldCell),
+        );
+        oldNew[1] = newCell;
+        if (oldNew[0] === oldNew[1]) {
+          if (collIsEmpty(mapSet(row, cellId))) {
+            if (collIsEmpty(mapSet(table, rowId))) {
+              if (collIsEmpty(mapSet(delta, tableId))) {
+                currentId = backwardIds.pop();
+                checkpointsChanged = 1;
+              }
+            }
+          }
+        }
+        callListenersIfChanged();
+      }
+    },
+  );
+  const addCheckpointImpl = (label = '') => {
+    if (isUndefined(currentId)) {
+      currentId = '' + nextCheckpointId++;
+      mapSet(deltas, currentId, delta);
+      setCheckpoint(currentId, label);
+      delta = mapNew();
+      checkpointsChanged = 1;
+    }
+    return currentId;
+  };
+  const goBackwardImpl = () => {
+    if (!arrayIsEmpty(backwardIds)) {
+      forwardIds.unshift(addCheckpointImpl());
+      updateStore(0, currentId);
+      currentId = backwardIds.pop();
+      checkpointsChanged = 1;
+    }
+  };
+  const goForwardImpl = () => {
+    if (!arrayIsEmpty(forwardIds)) {
+      backwardIds.push(currentId);
+      currentId = forwardIds.shift();
+      updateStore(1, currentId);
+      checkpointsChanged = 1;
+    }
+  };
+  const callListenersIfChanged = () => {
+    if (checkpointsChanged) {
+      callListeners(checkpointIdsListeners);
+      checkpointsChanged = 0;
+    }
+  };
+  const setSize = (size) => {
+    backwardIdsSize = size;
+    trimBackwardsIds();
+    return checkpoints;
+  };
+  const addCheckpoint = (label) => {
+    const id = addCheckpointImpl(label);
+    callListenersIfChanged();
+    return id;
+  };
+  const setCheckpoint = (checkpointId, label) => {
+    if (
+      collHas(deltas, checkpointId) &&
+      mapGet(labels, checkpointId) !== label
+    ) {
+      mapSet(labels, checkpointId, label);
+      callListeners(checkpointListeners, [checkpointId]);
+    }
+    return checkpoints;
+  };
+  const getStore = () => store;
+  const getCheckpointIds = () => [[...backwardIds], currentId, [...forwardIds]];
+  const getCheckpoint = (checkpointId) => mapGet(labels, checkpointId);
+  const goBackward = () => {
+    goBackwardImpl();
+    callListenersIfChanged();
+    return checkpoints;
+  };
+  const goForward = () => {
+    goForwardImpl();
+    callListenersIfChanged();
+    return checkpoints;
+  };
+  const goTo = (checkpointId) => {
+    const action = arrayHas(backwardIds, checkpointId)
+      ? goBackwardImpl
+      : arrayHas(forwardIds, checkpointId)
+      ? goForwardImpl
+      : null;
+    while (!isUndefined(action) && checkpointId != currentId) {
+      action();
+    }
+    callListenersIfChanged();
+    return checkpoints;
+  };
+  const addCheckpointIdsListener = (listener) =>
+    addListener(listener, checkpointIdsListeners);
+  const addCheckpointListener = (checkpointId, listener) =>
+    addListener(listener, checkpointListeners, [checkpointId]);
+  const delListener = (listenerId2) => {
+    delListenerImpl(listenerId2);
+    return checkpoints;
+  };
+  const clear = () => {
+    clearCheckpointIds(backwardIds);
+    clearCheckpointIds(forwardIds);
+    if (!isUndefined(currentId)) {
+      clearCheckpointId(currentId);
+    }
+    currentId = void 0;
+    nextCheckpointId = 0;
+    addCheckpoint();
+    return checkpoints;
+  };
+  const destroy = () => {
+    store.delListener(listenerId);
+  };
+  const getListenerStats = () => ({
+    checkpointIds: collSize(checkpointIdsListeners),
+    checkpoint: collSize2(checkpointListeners),
+  });
+  const checkpoints = {
+    setSize,
+    addCheckpoint,
+    setCheckpoint,
+    getStore,
+    getCheckpointIds,
+    getCheckpoint,
+    goBackward,
+    goForward,
+    goTo,
+    addCheckpointIdsListener,
+    addCheckpointListener,
+    delListener,
+    clear,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(checkpoints.clear());
+});
+
+export {createCheckpoints};

package/lib/debug/common.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The common module of the TinyBase project provides a small collection of
+ * common types used across other modules.
+ *
+ * @packageDocumentation
+ * @module common
+ */
+
+/**
+ * The Json type is a simple alias for a string, but is used to indicate that
+ * the string should be considered to be a JSON serialization of an object.
+ *
+ * @category General
+ */
+export type Json = string;
+
+/**
+ * The Ids type is a simple alias for an array of strings, but is used to
+ * indicate that the strings should be considered to be the keys of objects
+ * (such as the Row Id strings used in a Table).
+ *
+ * @category Identity
+ */
+export type Ids = Id[];
+
+/**
+ * The Id type is a simple alias for a string, but is used to indicate that the
+ * string should be considered to be the key of an object (such as a Row Id
+ * string used in a Table).
+ *
+ * @category Identity
+ */
+export type Id = string;
+
+/**
+ * The Id type is a simple alias for the union of a string or `null` value,
+ * where the string should be considered to be the key of an objects (such as a
+ * Row Id string used in a Table), and typically `null` indicates a wildcard -
+ * such as when used in the Store addRowListener method.
+ *
+ * @category Identity
+ */
+export type IdOrNull = Id | null;
+
+/**
+ * The ParameterizedCallback type represents a generic function that will take
+ * an optional parameter - such as the handler of a DOM event.
+ *
+ * @category Callback
+ */
+export type ParameterizedCallback<Parameter> = (parameter?: Parameter) => void;
+
+/**
+ * The Callback type represents a function that is used as a callback and which
+ * does not take a parameter.
+ *
+ * @category Callback
+ */
+export type Callback = () => void;