tinybase 1.0.4 → 1.1.0-beta.2

package/lib/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,36 @@ 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.

package/lib/checkpoints.js

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

package/lib/debug/checkpoints.js

@@ -5,6 +5,8 @@ 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) =>
@@ -22,6 +24,8 @@ 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) => {
@@ -74,7 +78,7 @@ const getListenerFunctions = (getThing) => {
   const allListeners = mapNew();
   const addListener = (listener, deepSet, idOrNulls = []) => {
     thing ??= getThing();
-    const id = listenerPool.pop() ?? '' + nextId++;
+    const id = arrayPop(listenerPool) ?? '' + nextId++;
     mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
     addDeepSet(deepSet, id, idOrNulls);
     return id;
@@ -95,7 +99,7 @@ const getListenerFunctions = (getThing) => {
         forDeepSet(collDel)(deepSet, id, ...idOrNulls);
         mapSet(allListeners, id);
         if (arrayLength(listenerPool) < 1e3) {
-          listenerPool.push(id);
+          arrayPush(listenerPool, id);
         }
         return idOrNulls;
       },
@@ -171,7 +175,7 @@ const createCheckpoints = getCreateFunction((store) => {
     (_store, tableId, rowId, cellId, newCell, oldCell) => {
       if (listening) {
         ifNotUndefined(currentId, () => {
-          backwardIds.push(currentId);
+          arrayPush(backwardIds, currentId);
           trimBackwardsIds();
           clearCheckpointIds(forwardIds);
           currentId = void 0;
@@ -190,7 +194,7 @@ const createCheckpoints = getCreateFunction((store) => {
           if (collIsEmpty(mapSet(row, cellId))) {
             if (collIsEmpty(mapSet(table, rowId))) {
               if (collIsEmpty(mapSet(delta, tableId))) {
-                currentId = backwardIds.pop();
+                currentId = arrayPop(backwardIds);
                 checkpointsChanged = 1;
               }
             }
@@ -214,13 +218,13 @@ const createCheckpoints = getCreateFunction((store) => {
     if (!arrayIsEmpty(backwardIds)) {
       forwardIds.unshift(addCheckpointImpl());
       updateStore(0, currentId);
-      currentId = backwardIds.pop();
+      currentId = arrayPop(backwardIds);
       checkpointsChanged = 1;
     }
   };
   const goForwardImpl = () => {
     if (!arrayIsEmpty(forwardIds)) {
-      backwardIds.push(currentId);
+      arrayPush(backwardIds, currentId);
       currentId = forwardIds.shift();
       updateStore(1, currentId);
       checkpointsChanged = 1;
@@ -251,6 +255,8 @@ const createCheckpoints = getCreateFunction((store) => {
   };
   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 = () => {
@@ -307,6 +313,7 @@ const createCheckpoints = getCreateFunction((store) => {
     setCheckpoint,
     getStore,
     getCheckpointIds,
+    forEachCheckpoint,
     hasCheckpoint,
     getCheckpoint,
     goBackward,

package/lib/debug/indexes.d.ts

@@ -11,7 +11,7 @@
  * @module indexes
  */
 
-import {GetCell, Store} from './store.d';
+import {GetCell, RowCallback, Store} from './store.d';
 import {Id, IdOrNull, Ids, SortKey} from './common.d';
 
 /**
@@ -43,6 +43,42 @@ export type Index = {[sliceId: Id]: Slice};
  */
 export type Slice = Ids;
 
+/**
+ * The IndexCallback type describes a function that takes an Index's Id and a
+ * callback to loop over each Slice within it.
+ *
+ * A IndexCallback is provided when using the forEachIndex method, so that you
+ * can do something based on every Index in the Indexes object. See that method
+ * for specific examples.
+ *
+ * @param indexId The Id of the Index that the callback can operate on.
+ * @param forEachRow A function that will let you iterate over the Slice objects
+ * in this Index.
+ * @category Callback
+ */
+export type IndexCallback = (
+  indexId: Id,
+  forEachSlice: (sliceCallback: SliceCallback) => void,
+) => void;
+
+/**
+ * The SliceCallback type describes a function that takes a Slice's Id and a
+ * callback to loop over each Row within it.
+ *
+ * A SliceCallback is provided when using the forEachSlice method, so that you
+ * can do something based on every Slice in an Index. See that method for
+ * specific examples.
+ *
+ * @param sliceId The Id of the Slice that the callback can operate on.
+ * @param forEachRow A function that will let you iterate over the Row objects
+ * in this Slice.
+ * @category Callback
+ */
+export type SliceCallback = (
+  sliceId: Id,
+  forEachRow: (rowCallback: RowCallback) => void,
+) => void;
+
 /**
  * The SliceIdsListener type describes a function that is used to listen to
  * changes to the Slice Ids in an Index.
@@ -362,6 +398,83 @@ export interface Indexes {
    */
   getIndexIds(): Ids;
 
+  /**
+   * The forEachIndex method takes a function that it will then call for each
+   * Index in a specified Indexes object.
+   *
+   * This method is useful for iterating over the structure of the Indexes
+   * object in a functional style. The `indexCallback` parameter is a
+   * IndexCallback function that will be called with the Id of each Index, and
+   * with a function that can then be used to iterate over each Slice of the
+   * Index, should you wish.
+   *
+   * @param indexCallback The function that should be called for every Index.
+   * @example
+   * This example iterates over each Index in an Indexes object, and lists each
+   * Slice Id within them.
+   *
+   * ```js
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog', color: 'brown'},
+   *   felix: {species: 'cat', color: 'black'},
+   *   cujo: {species: 'dog', color: 'black'},
+   * });
+   * const indexes = createIndexes(store)
+   *   .setIndexDefinition('bySpecies', 'pets', 'species')
+   *   .setIndexDefinition('byColor', 'pets', 'color');
+   *
+   * indexes.forEachIndex((indexId, forEachSlice) => {
+   *   console.log(indexId);
+   *   forEachSlice((sliceId) => console.log(`- ${sliceId}`));
+   * });
+   * // -> 'bySpecies'
+   * // -> '- dog'
+   * // -> '- cat'
+   * // -> 'byColor'
+   * // -> '- brown'
+   * // -> '- black'
+   * ```
+   * @category Iterator
+   */
+  forEachIndex(indexCallback: IndexCallback): void;
+
+  /**
+   * The forEachSlice method takes a function that it will then call for each
+   * Slice in a specified Index.
+   *
+   * This method is useful for iterating over the Slice structure of the Index
+   * in a functional style. The `rowCallback` parameter is a RowCallback
+   * function that will be called with the Id and value of each Row in the
+   * Slice.
+   *
+   * @param indexId The Id of the Index to iterate over.
+   * @param sliceCallback The function that should be called for every Slice.
+   * @example
+   * This example iterates over each Row in a Slice, and lists its Id.
+   *
+   * ```js
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog'},
+   *   felix: {species: 'cat'},
+   *   cujo: {species: 'dog'},
+   * });
+   * const indexes = createIndexes(store);
+   * indexes.setIndexDefinition('bySpecies', 'pets', 'species');
+   *
+   * indexes.forEachSlice('bySpecies', (sliceId, forEachRow) => {
+   *   console.log(sliceId);
+   *   forEachRow((rowId) => console.log(`- ${rowId}`));
+   * });
+   * // -> 'dog'
+   * // -> '- fido'
+   * // -> '- cujo'
+   * // -> 'cat'
+   * // -> '- felix'
+   * ```
+   * @category Iterator
+   */
+  forEachSlice(indexId: Id, sliceCallback: SliceCallback): void;
+
   /**
    * The hasIndex method returns a boolean indicating whether a given Index
    * exists in the Indexes object.

package/lib/debug/indexes.js

@@ -12,6 +12,8 @@ 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 arrayPop = (array) => array.pop();
 
 const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
@@ -57,6 +59,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   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);
@@ -147,6 +150,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   return [
     getStore,
     getThingIds,
+    forEachThing,
     hasThing,
     getTableId,
     getThing,
@@ -201,7 +205,7 @@ const getListenerFunctions = (getThing) => {
   const allListeners = mapNew();
   const addListener = (listener, deepSet, idOrNulls = []) => {
     thing ??= getThing();
-    const id = listenerPool.pop() ?? '' + nextId++;
+    const id = arrayPop(listenerPool) ?? '' + nextId++;
     mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
     addDeepSet(deepSet, id, idOrNulls);
     return id;
@@ -222,7 +226,7 @@ const getListenerFunctions = (getThing) => {
         forDeepSet(collDel)(deepSet, id, ...idOrNulls);
         mapSet(allListeners, id);
         if (arrayLength(listenerPool) < 1e3) {
-          listenerPool.push(id);
+          arrayPush(listenerPool, id);
         }
         return idOrNulls;
       },
@@ -254,6 +258,7 @@ const createIndexes = getCreateFunction((store) => {
   const [
     getStore,
     getIndexIds,
+    forEachIndexImpl,
     hasIndex,
     getTableId,
     getIndex,
@@ -363,6 +368,26 @@ const createIndexes = getCreateFunction((store) => {
     );
     return indexes;
   };
+  const forEachIndex = (indexCallback) =>
+    forEachIndexImpl((indexId, slices) =>
+      indexCallback(indexId, (sliceCallback) =>
+        forEachSliceImpl(indexId, sliceCallback, slices),
+      ),
+    );
+  const forEachSlice = (indexId, sliceCallback) =>
+    forEachSliceImpl(indexId, sliceCallback, getIndex(indexId));
+  const forEachSliceImpl = (indexId, sliceCallback, slices) => {
+    const tableId = getTableId(indexId);
+    collForEach(slices, (rowIds, sliceId) =>
+      sliceCallback(sliceId, (rowCallback) =>
+        collForEach(rowIds, (rowId) =>
+          rowCallback(rowId, (cellCallback) =>
+            store.forEachCell(tableId, rowId, cellCallback),
+          ),
+        ),
+      ),
+    );
+  };
   const delIndexDefinition = (indexId) => {
     delDefinition(indexId);
     return indexes;
@@ -387,6 +412,8 @@ const createIndexes = getCreateFunction((store) => {
     delIndexDefinition,
     getStore,
     getIndexIds,
+    forEachIndex,
+    forEachSlice,
     hasIndex,
     hasSlice,
     getTableId,

package/lib/debug/metrics.d.ts

@@ -22,6 +22,20 @@ import {Id, IdOrNull, Ids} from './common.d';
  */
 export type Metric = number;
 
+/**
+ * The MetricCallback type describes a function that takes a Metric's Id and a
+ * callback to loop over each Row within it.
+ *
+ * A MetricCallback is provided when using the forEachMetric method, so that you
+ * can do something based on every Metric in the Metrics object. See that method
+ * for specific examples.
+ *
+ * @param metricId The Id of the Metric that the callback can operate on.
+ * @param metric The value of the Metric.
+ * @category Callback
+ */
+export type MetricCallback = (metricId: Id, metric?: Metric) => void;
+
 /**
  * The Aggregate type describes a custom function that takes an array or numbers
  * and returns an aggregate that is used as a Metric.
@@ -478,6 +492,38 @@ export interface Metrics {
    */
   getMetricIds(): Ids;
 
+  /**
+   * The forEachMetric method takes a function that it will then call for each
+   * Metric in the Metrics object.
+   *
+   * This method is useful for iterating over all the Metrics in a functional
+   * style. The `metricCallback` parameter is a MetricCallback function that
+   * will be called with the Id of each Metric and its value.
+   *
+   * @param metricCallback The function that should be called for every Metric.
+   * @example
+   * This example iterates over each Metric in a Metrics object.
+   *
+   * ```js
+   * const store = createStore().setTable('species', {
+   *   dog: {price: 5},
+   *   cat: {price: 4},
+   *   worm: {price: 1},
+   * });
+   * const metrics = createMetrics(store)
+   *   .setMetricDefinition('highestPrice', 'species', 'max', 'price')
+   *   .setMetricDefinition('lowestPrice', 'species', 'min', 'price');
+   *
+   * metrics.forEachMetric((metricId, metric) => {
+   *   console.log([metricId, metric]);
+   * });
+   * // -> ['highestPrice', 5]
+   * // -> ['lowestPrice', 1]
+   * ```
+   * @category Iterator
+   */
+  forEachMetric(metricCallback: MetricCallback): void;
+
   /**
    * The hasMetric method returns a boolean indicating whether a given Metric
    * exists in the Metrics object, and has a value.

package/lib/debug/metrics.js

@@ -13,6 +13,8 @@ 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 arrayPop = (array) => array.pop();
 
 const mathMax = Math.max;
 const mathMin = Math.min;
@@ -62,6 +64,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   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);
@@ -152,6 +155,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   return [
     getStore,
     getThingIds,
+    forEachThing,
     hasThing,
     getTableId,
     getThing,
@@ -204,7 +208,7 @@ const getListenerFunctions = (getThing) => {
   const allListeners = mapNew();
   const addListener = (listener, deepSet, idOrNulls = []) => {
     thing ??= getThing();
-    const id = listenerPool.pop() ?? '' + nextId++;
+    const id = arrayPop(listenerPool) ?? '' + nextId++;
     mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
     addDeepSet(deepSet, id, idOrNulls);
     return id;
@@ -225,7 +229,7 @@ const getListenerFunctions = (getThing) => {
         forDeepSet(collDel)(deepSet, id, ...idOrNulls);
         mapSet(allListeners, id);
         if (arrayLength(listenerPool) < 1e3) {
-          listenerPool.push(id);
+          arrayPush(listenerPool, id);
         }
         return idOrNulls;
       },
@@ -296,6 +300,7 @@ const createMetrics = getCreateFunction((store) => {
   const [
     getStore,
     getMetricIds,
+    forEachMetric,
     hasMetric,
     getTableId,
     getMetric,
@@ -381,6 +386,7 @@ const createMetrics = getCreateFunction((store) => {
     delMetricDefinition,
     getStore,
     getMetricIds,
+    forEachMetric,
     hasMetric,
     getTableId,
     getMetric,

package/lib/debug/relationships.d.ts

@@ -11,7 +11,7 @@
  * @module relationships
  */
 
-import {GetCell, Store} from './store.d';
+import {GetCell, RowCallback, Store} from './store.d';
 import {Id, IdOrNull, Ids} from './common.d';
 
 /**
@@ -39,6 +39,25 @@ export type Relationship = {
   linkedRowIds: {[firstRowId: Id]: Ids};
 };
 
+/**
+ * The RelationshipCallback type describes a function that takes a
+ * Relationship's Id and a callback to loop over each local Row within it.
+ *
+ * A RelationshipCallback is provided when using the forEachRelationship method,
+ * so that you can do something based on every Relationship in the Relationships
+ * object. See that method for specific examples.
+ *
+ * @param relationshipId The Id of the Relationship that the callback can
+ * operate on.
+ * @param forEachRow A function that will let you iterate over the local Row
+ * objects in this Relationship.
+ * @category Callback
+ */
+export type RelationshipCallback = (
+  relationshipId: Id,
+  forEachRow: (rowCallback: RowCallback) => void,
+) => void;
+
 /**
  * The RemoteRowIdListener type describes a function that is used to listen to
  * changes to the remote Row Id end of a Relationship.
@@ -405,6 +424,49 @@ export interface Relationships {
    */
   getRelationshipIds(): Ids;
 
+  /**
+   * The forEachRelationship method takes a function that it will then call for
+   * each Relationship in a specified Relationships object.
+   *
+   * This method is useful for iterating over the structure of the Relationships
+   * object in a functional style. The `relationshipCallback` parameter is a
+   * RelationshipCallback function that will be called with the Id of each
+   * Relationship, and with a function that can then be used to iterate over
+   * each local Row involved in the Relationship.
+   *
+   * @param relationshipCallback The function that should be called for every
+   * Relationship.
+   * @example
+   * This example iterates over each Relationship in a Relationships object, and
+   * lists each Row Id within them.
+   *
+   * ```js
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog', next: 'felix'},
+   *   felix: {species: 'cat', next: 'cujo'},
+   *   cujo: {species: 'dog'},
+   * });
+   * const relationships = createRelationships(store)
+   *   .setRelationshipDefinition('petSpecies', 'pets', 'species', 'species')
+   *   .setRelationshipDefinition('petSequence', 'pets', 'pets', 'next');
+   *
+   * relationships.forEachRelationship((relationshipId, forEachRow) => {
+   *   console.log(relationshipId);
+   *   forEachRow((rowId) => console.log(`- ${rowId}`));
+   * });
+   * // -> 'petSpecies'
+   * // -> '- fido'
+   * // -> '- felix'
+   * // -> '- cujo'
+   * // -> 'petSequence'
+   * // -> '- fido'
+   * // -> '- felix'
+   * // -> '- cujo'
+   * ```
+   * @category Iterator
+   */
+  forEachRelationship(relationshipCallback: RelationshipCallback): void;
+
   /**
    * The hasRelationship method returns a boolean indicating whether a given
    * Relationship exists in the Relationships object.