tinybase 1.0.2 → 1.1.0-beta.0

package/lib/checkpoints.js

@@ -0,0 +1 @@
+const e=(e,t)=>e.includes(t),t=(e,t)=>e.forEach(t),n=e=>e.length,s=e=>0==n(e),o=e=>e.slice(1),r=(e,t)=>e.push(t),c=e=>e.pop(),l=e=>null==e,i=(e,t,n)=>l(e)?n?.():t(e),d=(e,t)=>e?.has(t)??!1,a=e=>l(e)||0==(e=>e.size)(e),h=(e,t)=>e?.forEach(t),u=(e,t)=>e?.delete(t),p=e=>new Map(e),C=(e,t)=>e?.get(t),g=(e,t,n)=>l(n)?(u(e,t),e):e?.set(t,n),k=(e,t,n,s)=>(d(e,t)||(s?.(n),e.set(t,n)),C(e,t)),f=e=>new Set(e),L=(e,t,r)=>n(r)<2?((e,t)=>e?.add(t))(s(r)?e:k(e,r[0],f()),t):L(k(e,r[0],p()),t,o(r)),v=e=>{const n=(r,c,...l)=>i(r,(r=>s(l)?e(r,c):t([l[0],null],(e=>n(C(r,e),c,...o(l))))));return n},w=Object.freeze,S=(e=>{const t=new WeakMap;return n=>(t.has(n)||t.set(n,e(n)),t.get(n))})((o=>{let S,z,E,I=100,M=p(),b=1;const j=f(),x=p(),[y,B,F]=(e=>{let s,o=0;const d=[],a=p();return[(t,n,r=[])=>{s??=e();const l=c(d)??""+o++;return g(a,l,[t,n,r]),L(n,l,r),l},(e,t=[],...n)=>v(h)(e,(e=>i(C(a,e),(([e])=>e(s,...t,...n)))),...t),e=>i(C(a,e),(([,t,s])=>(v(u)(t,e,...s),g(a,e),n(d)<1e3&&r(d,e),s)),(()=>[])),(e,o,r)=>i(C(a,e),(([e,,c])=>{const i=(...d)=>{const a=n(d);a==n(c)?e(s,...d,...r(d)):l(c[a])?t(o[a](...d),(e=>i(...d,e))):i(...d,c[a])};i()}))]})((()=>V)),O=p(),T=p(),W=[],m=[],q=(e,t)=>{b=0,o.transaction((()=>h(C(O,t),((t,n)=>h(t,((t,s)=>h(t,((t,r)=>l(t[e])?o.delCell(n,s,r,!0):o.setCell(n,s,r,t[e]))))))))),b=1},A=e=>{g(O,e),g(T,e),B(x,[e])},D=(e,s)=>t(((e,t)=>e.splice(0,t))(e,s??n(e)),A),G=()=>D(W,n(W)-I),H=o.addCellListener(null,null,null,((e,t,n,s,o,l)=>{if(b){i(S,(()=>{r(W,S),G(),D(m),S=void 0,E=1}));const e=k(M,t,p()),d=k(e,n,p()),h=k(d,s,[void 0,void 0],(e=>e[0]=l));h[1]=o,h[0]===h[1]&&a(g(d,s))&&a(g(e,n))&&a(g(M,t))&&(S=c(W),E=1),P()}})),J=(e="")=>(l(S)&&(S=""+z++,g(O,S,M),R(S,e),M=p(),E=1),S),K=()=>{s(W)||(m.unshift(J()),q(0,S),S=c(W),E=1)},N=()=>{s(m)||(r(W,S),S=m.shift(),q(1,S),E=1)},P=()=>{E&&(B(j),E=0)},Q=e=>{const t=J(e);return P(),t},R=(e,t)=>(U(e)&&C(T,e)!==t&&(g(T,e,t),B(x,[e])),V),U=e=>d(O,e),V={setSize:e=>(I=e,G(),V),addCheckpoint:Q,setCheckpoint:R,getStore:()=>o,getCheckpointIds:()=>[[...W],S,[...m]],forEachCheckpoint:e=>{return t=e,h(T,((e,n)=>t(n,e)));var t},hasCheckpoint:U,getCheckpoint:e=>C(T,e),goBackward:()=>(K(),P(),V),goForward:()=>(N(),P(),V),goTo:t=>{const n=e(W,t)?K:e(m,t)?N:null;for(;!l(n)&&t!=S;)n();return P(),V},addCheckpointIdsListener:e=>y(e,j),addCheckpointListener:(e,t)=>y(t,x,[e]),delListener:e=>(F(e),V),clear:()=>(D(W),D(m),l(S)||A(S),S=void 0,z=0,Q(),V),destroy:()=>{o.delListener(H)},getListenerStats:()=>({})};return w(V.clear())}));export{S as createCheckpoints};

package/lib/common.d.ts

@@ -0,0 +1,115 @@
+/**
+ * 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;
+
+/**
+ * The SortKey type represents a value that can be used by a sort function.
+ *
+ * @category Parameter
+ */
+export type SortKey = string | number | boolean;
+
+/**
+ * The defaultSorter function is provided as a convenience to sort keys
+ * alphanumerically, and can be provided to the `sliceIdSorter` and
+ * `rowIdSorter` parameters of the setIndexDefinition method in the indexes
+ * module, for example.
+ *
+ * @param sortKey1 The first item of the pair to compare.
+ * @param sortKey2 The second item of the pair to compare.
+ * @returns A number indicating how to sort the pair.
+ * @example
+ * This example creates an Indexes object.
+ *
+ * ```js
+ * const store = createStore();
+ * const indexes = createIndexes(store);
+ * console.log(indexes.getIndexIds());
+ * // -> []
+ * ```
+ * @example
+ * This example creates a Store, creates an Indexes object, and defines an
+ * Index based on the first letter of the pets' names. The Slice Ids (and Row
+ * Ids within them) are alphabetically sorted using the defaultSorter function.
+ *
+ * ```js
+ * const store = createStore().setTable('pets', {
+ *   fido: {species: 'dog'},
+ *   felix: {species: 'cat'},
+ *   cujo: {species: 'dog'},
+ * });
+ *
+ * const indexes = createIndexes(store);
+ * indexes.setIndexDefinition(
+ *   'byFirst', //              indexId
+ *   'pets', //                 tableId
+ *   (_, rowId) => rowId[0], // each Row's Slice Id
+ *   (_, rowId) => rowId, //    each Row's sort key
+ *   defaultSorter, //          sort Slice Ids
+ *   defaultSorter, //          sort Row Ids by sort key
+ * );
+ *
+ * console.log(indexes.getSliceIds('byFirst'));
+ * // -> ['c', 'f']
+ * console.log(indexes.getSliceRowIds('byFirst', 'f'));
+ * // -> ['felix', 'fido']
+ * ```
+ * @category Convenience
+ */
+export function defaultSorter(sortKey1: SortKey, sortKey2: SortKey): number;

package/lib/common.js

@@ -0,0 +1 @@
+const o=(o,t)=>o<t?-1:1;export{o as defaultSorter};

package/lib/debug/checkpoints.d.ts

@@ -33,6 +33,20 @@ import {Store} from './store.d';
  */
 export type CheckpointIds = [Ids, Id | undefined, Ids];
 
+/**
+ * The CheckpointCallback type describes a function that takes a Checkpoint's
+ * Id.
+ *
+ * A CheckpointCallback is provided when using the forEachCheckpoint method,
+ * so that you can do something based on every Checkpoint in the Checkpoints
+ * object. See that method for specific examples.
+ *
+ * @param checkpointId The Id of the Checkpoint that the callback can operate
+ * on.
+ * @category Callback
+ */
+export type CheckpointCallback = (checkpointId: Id, label?: string) => void;
+
 /**
  * The CheckpointIdsListener type describes a function that is used to listen to
  * changes to the checkpoint Ids in a Checkpoints object.
@@ -353,6 +367,58 @@ export interface Checkpoints {
    */
   getCheckpointIds(): CheckpointIds;
 
+  /**
+   * The forEachCheckpoint method takes a function that it will then call for
+   * each Checkpoint in a specified Checkpoints object.
+   *
+   * This method is useful for iterating over the structure of the Checkpoints
+   * object in a functional style. The `checkpointCallback` parameter is a
+   * CheckpointCallback function that will be called with the Id of each
+   * Checkpoint.
+   *
+   * @param checkpointCallback The function that should be called for every
+   * Checkpoint.
+   * @example
+   * This example iterates over each Checkpoint in a Checkpoints object.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {sold: false}}});
+   * const checkpoints = createCheckpoints(store);
+   * store.setCell('pets', 'fido', 'sold', true);
+   * checkpoints.addCheckpoint('sale');
+   *
+   * checkpoints.forEachCheckpoint((checkpointId, label) => {
+   *   console.log(`${checkpointId}:${label}`);
+   * });
+   * // -> '0:'
+   * // -> '1:sale'
+   * ```
+   * @category Iterator
+   */
+  forEachCheckpoint(checkpointCallback: CheckpointCallback): void;
+
+  /**
+   * The hasCheckpoint method returns a boolean indicating whether a given
+   * Checkpoint exists in the Checkpoints object.
+   *
+   * @param checkpointId The Id of a possible Checkpoint in the Checkpoints
+   * object.
+   * @returns Whether a Checkpoint with that Id exists.
+   * @example
+   * This example shows two simple Checkpoint existence checks.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {sold: false}}});
+   * const checkpoints = createCheckpoints(store);
+   * console.log(checkpoints.hasCheckpoint('0'));
+   * // -> true
+   * console.log(checkpoints.hasCheckpoint('1'));
+   * // -> false
+   * ```
+   * @category Getter
+   */
+  hasCheckpoint(checkpointId: Id): boolean;
+
   /**
    * The getCheckpoint method fetches the label for a checkpoint, if it had been
    * provided at the time of the addCheckpoint method or set subsequently with

package/lib/debug/checkpoints.js

@@ -0,0 +1,332 @@
+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 arrayPush = (array, value) => array.push(value);
+const arrayPop = (array) => array.pop();
+
+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 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 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 = arrayPop(listenerPool) ?? '' + 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) {
+          arrayPush(listenerPool, 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, () => {
+          arrayPush(backwardIds, 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 = arrayPop(backwardIds);
+                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 = arrayPop(backwardIds);
+      checkpointsChanged = 1;
+    }
+  };
+  const goForwardImpl = () => {
+    if (!arrayIsEmpty(forwardIds)) {
+      arrayPush(backwardIds, 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 (hasCheckpoint(checkpointId) && mapGet(labels, checkpointId) !== label) {
+      mapSet(labels, checkpointId, label);
+      callListeners(checkpointListeners, [checkpointId]);
+    }
+    return checkpoints;
+  };
+  const getStore = () => store;
+  const getCheckpointIds = () => [[...backwardIds], currentId, [...forwardIds]];
+  const forEachCheckpoint = (checkpointCallback) =>
+    mapForEach(labels, checkpointCallback);
+  const hasCheckpoint = (checkpointId) => collHas(deltas, checkpointId);
+  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,
+    forEachCheckpoint,
+    hasCheckpoint,
+    getCheckpoint,
+    goBackward,
+    goForward,
+    goTo,
+    addCheckpointIdsListener,
+    addCheckpointListener,
+    delListener,
+    clear,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(checkpoints.clear());
+});
+
+export {createCheckpoints};

package/lib/debug/common.js

@@ -0,0 +1,3 @@
+const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
+
+export {defaultSorter};