tinybase 1.0.1 → 1.0.5

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,72 @@ 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.
+   *
+   * @param relationshipId The Id of a possible Relationship in the
+   * Relationships object.
+   * @returns Whether a Relationship with that Id exists.
+   * @example
+   * This example shows two simple Relationship existence checks.
+   *
+   * ```js
+   * const relationships = createRelationships(
+   *   createStore(),
+   * ).setRelationshipDefinition('petSpecies', 'pets', 'species', 'species');
+   * console.log(relationships.hasRelationship('petSpecies'));
+   * // -> true
+   * console.log(relationships.hasRelationship('petColor'));
+   * // -> false
+   * ```
+   * @category Getter
+   */
+  hasRelationship(indexId: Id): boolean;
+
   /**
    * The getLocalTableId method returns the Id of the underlying local Table
    * that is used in the Relationship.

package/lib/debug/relationships.js

@@ -52,6 +52,8 @@ 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);
   const setThing = (id, thing) => mapSet(things, id, thing);
@@ -141,6 +143,8 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   return [
     getStore,
     getThingIds,
+    forEachThing,
+    hasThing,
     getTableId,
     getThing,
     setThing,
@@ -247,6 +251,8 @@ const createRelationships = getCreateFunction((store) => {
   const [
     getStore,
     getRelationshipIds,
+    forEachRelationshipImpl,
+    hasRelationship,
     getLocalTableId,
     getRelationship,
     _setRelationship,
@@ -360,6 +366,12 @@ const createRelationships = getCreateFunction((store) => {
     );
     return relationships;
   };
+  const forEachRelationship = (relationshipCallback) =>
+    forEachRelationshipImpl((relationshipId) =>
+      relationshipCallback(relationshipId, (rowCallback) =>
+        store.forEachRow(getLocalTableId(relationshipId), rowCallback),
+      ),
+    );
   const delRelationshipDefinition = (relationshipId) => {
     mapSet(remoteTableIds, relationshipId);
     delDefinition(relationshipId);
@@ -400,6 +412,8 @@ const createRelationships = getCreateFunction((store) => {
     delRelationshipDefinition,
     getStore,
     getRelationshipIds,
+    forEachRelationship,
+    hasRelationship,
     getLocalTableId,
     getRemoteTableId,
     getRemoteRowId,

package/lib/debug/store.d.ts

@@ -89,7 +89,7 @@ export type Row = {[cellId: Id]: Cell};
 export type Cell = string | number | boolean;
 
 /**
- * The TableCallback type describes a function that takes a Tables's Id and a
+ * The TableCallback type describes a function that takes a Table's Id and a
  * callback to loop over each Row within it.
  *
  * A TableCallback is provided when using the forEachTable method, so that you
@@ -867,6 +867,26 @@ export interface Store {
    */
   getCell(tableId: Id, rowId: Id, cellId: Id): Cell | undefined;
 
+  /**
+   * The hasTables method returns a boolean indicating whether any Table objects
+   * exist in the Store.
+   *
+   * @returns Whether any Tables exist.
+   * @example
+   * This example shows simple existence checks.
+   *
+   * ```js
+   * const store = createStore();
+   * console.log(store.hasTables());
+   * // -> false
+   * store.setTables({pets: {fido: {species: 'dog'}}});
+   * console.log(store.hasTables());
+   * // -> true
+   * ```
+   * @category Getter
+   */
+  hasTables(): boolean;
+
   /**
    * The hasTable method returns a boolean indicating whether a given Table
    * exists in the Store.
@@ -1611,7 +1631,7 @@ export interface Store {
    *
    * This method is useful for iterating over the Table structure of the Store
    * in a functional style. The `tableCallback` parameter is a TableCallback
-   * function that will called with the Id of each Table, and with a function
+   * function that will be called with the Id of each Table, and with a function
    * that can then be used to iterate over each Row of the Table, should you
    * wish.
    *
@@ -1644,9 +1664,10 @@ export interface Store {
    *
    * This method is useful for iterating over the Row structure of the Table in
    * a functional style. The `rowCallback` parameter is a RowCallback function
-   * that will called with the Id of each Row, and with a function that can then
-   * be used to iterate over each Cell of the Row, should you wish.
+   * that will be called with the Id of each Row, and with a function that can
+   * then be used to iterate over each Cell of the Row, should you wish.
    *
+   * @param tableId The Id of the Table to iterate over.
    * @param rowCallback The function that should be called for every Row.
    * @example
    * This example iterates over each Row in a Table, and lists each Cell Id
@@ -1678,8 +1699,10 @@ export interface Store {
    *
    * This method is useful for iterating over the Cell structure of the Row in a
    * functional style. The `cellCallback` parameter is a CellCallback function
-   * that will called with the Id and value of each Cell.
+   * that will be called with the Id and value of each Cell.
    *
+   * @param tableId The Id of the Table containing the Row to iterate over.
+   * @param rowId The Id of the Row to iterate over.
    * @param cellCallback The function that should be called for every Cell.
    * @example
    * This example iterates over each Cell in a Row, and lists its value.

package/lib/debug/store.js

@@ -490,6 +490,7 @@ const createStore = () => {
     mapKeys(mapGet(mapGet(tablesMap, tableId), rowId));
   const getCell = (tableId, rowId, cellId) =>
     mapGet(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+  const hasTables = () => !collIsEmpty(tablesMap);
   const hasTable = (tableId) => collHas(tablesMap, tableId);
   const hasRow = (tableId, rowId) => collHas(mapGet(tablesMap, tableId), rowId);
   const hasCell = (tableId, rowId, cellId) =>
@@ -686,6 +687,7 @@ const createStore = () => {
     getRow,
     getCellIds,
     getCell,
+    hasTables,
     hasTable,
     hasRow,
     hasCell,

package/lib/debug/tinybase.js

@@ -110,6 +110,8 @@ 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);
   const setThing = (id, thing) => mapSet(things, id, thing);
@@ -199,6 +201,8 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   return [
     getStore,
     getThingIds,
+    forEachThing,
+    hasThing,
     getTableId,
     getThing,
     setThing,
@@ -429,10 +433,7 @@ const createCheckpoints = getCreateFunction((store) => {
     return id;
   };
   const setCheckpoint = (checkpointId, label) => {
-    if (
-      collHas(deltas, checkpointId) &&
-      mapGet(labels, checkpointId) !== label
-    ) {
+    if (hasCheckpoint(checkpointId) && mapGet(labels, checkpointId) !== label) {
       mapSet(labels, checkpointId, label);
       callListeners(checkpointListeners, [checkpointId]);
     }
@@ -440,6 +441,9 @@ 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 = () => {
     goBackwardImpl();
@@ -495,6 +499,8 @@ const createCheckpoints = getCreateFunction((store) => {
     setCheckpoint,
     getStore,
     getCheckpointIds,
+    forEachCheckpoint,
+    hasCheckpoint,
     getCheckpoint,
     goBackward,
     goForward,
@@ -517,6 +523,8 @@ const createIndexes = getCreateFunction((store) => {
   const [
     getStore,
     getIndexIds,
+    forEachIndexImpl,
+    hasIndex,
     getTableId,
     getIndex,
     setIndex,
@@ -529,6 +537,7 @@ const createIndexes = getCreateFunction((store) => {
   const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
     () => indexes,
   );
+  const hasSlice = (indexId, sliceId) => collHas(getIndex(indexId), sliceId);
   const setIndexDefinition = (
     indexId,
     tableId,
@@ -624,6 +633,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;
@@ -648,6 +677,10 @@ const createIndexes = getCreateFunction((store) => {
     delIndexDefinition,
     getStore,
     getIndexIds,
+    forEachIndex,
+    forEachSlice,
+    hasIndex,
+    hasSlice,
     getTableId,
     getSliceIds,
     getSliceRowIds,
@@ -705,6 +738,8 @@ const createMetrics = getCreateFunction((store) => {
   const [
     getStore,
     getMetricIds,
+    forEachMetric,
+    hasMetric,
     getTableId,
     getMetric,
     setMetric,
@@ -789,6 +824,8 @@ const createMetrics = getCreateFunction((store) => {
     delMetricDefinition,
     getStore,
     getMetricIds,
+    forEachMetric,
+    hasMetric,
     getTableId,
     getMetric,
     addMetricListener,
@@ -980,6 +1017,8 @@ const createRelationships = getCreateFunction((store) => {
   const [
     getStore,
     getRelationshipIds,
+    forEachRelationshipImpl,
+    hasRelationship,
     getLocalTableId,
     getRelationship,
     _setRelationship,
@@ -1093,6 +1132,12 @@ const createRelationships = getCreateFunction((store) => {
     );
     return relationships;
   };
+  const forEachRelationship = (relationshipCallback) =>
+    forEachRelationshipImpl((relationshipId) =>
+      relationshipCallback(relationshipId, (rowCallback) =>
+        store.forEachRow(getLocalTableId(relationshipId), rowCallback),
+      ),
+    );
   const delRelationshipDefinition = (relationshipId) => {
     mapSet(remoteTableIds, relationshipId);
     delDefinition(relationshipId);
@@ -1133,6 +1178,8 @@ const createRelationships = getCreateFunction((store) => {
     delRelationshipDefinition,
     getStore,
     getRelationshipIds,
+    forEachRelationship,
+    hasRelationship,
     getLocalTableId,
     getRemoteTableId,
     getRemoteRowId,
@@ -1469,6 +1516,7 @@ const createStore = () => {
     mapKeys(mapGet(mapGet(tablesMap, tableId), rowId));
   const getCell = (tableId, rowId, cellId) =>
     mapGet(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+  const hasTables = () => !collIsEmpty(tablesMap);
   const hasTable = (tableId) => collHas(tablesMap, tableId);
   const hasRow = (tableId, rowId) => collHas(mapGet(tablesMap, tableId), rowId);
   const hasCell = (tableId, rowId, cellId) =>
@@ -1665,6 +1713,7 @@ const createStore = () => {
     getRow,
     getCellIds,
     getCell,
+    hasTables,
     hasTable,
     hasRow,
     hasCell,

package/lib/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,131 @@ 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.
+   *
+   * @param indexId The Id of a possible Index in the Indexes object.
+   * @returns Whether an Index with that Id exists.
+   * @example
+   * This example shows two simple Index existence checks.
+   *
+   * ```js
+   * const indexes = createIndexes(createStore());
+   * indexes.setIndexDefinition('bySpecies', 'pets', 'species');
+   * console.log(indexes.hasIndex('bySpecies'));
+   * // -> true
+   * console.log(indexes.hasIndex('byColor'));
+   * // -> false
+   * ```
+   * @category Getter
+   */
+  hasIndex(indexId: Id): boolean;
+
+  /**
+   * The hasSlice method returns a boolean indicating whether a given Slice
+   * exists in the Indexes object.
+   *
+   * @param indexId The Id of a possible Index in the Indexes object.
+   * @param sliceId The Id of a possible Slice in the Index.
+   * @returns Whether a Slice with that Id exists.
+   * @example
+   * This example shows two simple Index existence checks.
+   *
+   * ```js
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog'},
+   *   felix: {species: 'cat'},
+   *   cujo: {species: 'dog'},
+   * });
+   * const indexes = createIndexes(store);
+   * indexes.setIndexDefinition('bySpecies', 'pets', 'species');
+   * console.log(indexes.hasSlice('bySpecies', 'dog'));
+   * // -> true
+   * console.log(indexes.hasSlice('bySpecies', 'worm'));
+   * // -> false
+   * ```
+   * @category Getter
+   */
+  hasSlice(indexId: Id, sliceId: Id): boolean;
+
   /**
    * The getTableId method returns the Id of the underlying Table that is
    * backing an Index.
@@ -473,7 +634,7 @@ export interface Indexes {
    * the Index change.
    * @returns A unique Id for the listener that can later be used to remove it.
    * @example
-   * This example creates a Store, a Indexes object, and then registers a
+   * This example creates a Store, an Indexes object, and then registers a
    * listener that responds to any changes to a specific Index.
    *
    * ```js
@@ -501,7 +662,7 @@ export interface Indexes {
    * indexes.delListener(listenerId);
    * ```
    * @example
-   * This example creates a Store, a Indexes object, and then registers a
+   * This example creates a Store, an Indexes object, and then registers a
    * listener that responds to any changes to any Index.
    *
    * ```js
@@ -558,7 +719,7 @@ export interface Indexes {
    * the Slice change.
    * @returns A unique Id for the listener that can later be used to remove it.
    * @example
-   * This example creates a Store, a Indexes object, and then registers a
+   * This example creates a Store, an Indexes object, and then registers a
    * listener that responds to any changes to a specific Slice.
    *
    * ```js
@@ -587,7 +748,7 @@ export interface Indexes {
    * indexes.delListener(listenerId);
    * ```
    * @example
-   * This example creates a Store, a Indexes object, and then registers a
+   * This example creates a Store, an Indexes object, and then registers a
    * listener that responds to any changes to any Slice.
    *
    * ```js
@@ -639,7 +800,7 @@ export interface Indexes {
    * @param listenerId The Id of the listener to remove.
    * @returns A reference to the Indexes object.
    * @example
-   * This example creates a Store, a Indexes object, registers a listener, and
+   * This example creates a Store, an Indexes object, registers a listener, and
    * then removes it.
    *
    * ```js

package/lib/indexes.js

@@ -1 +1 @@
-const e=e=>typeof e,t=e(""),s=(e,t)=>e.every(((s,n)=>0==n||t(e[n-1],s)<=0)),n=(e,t)=>e.sort(t),o=(e,t)=>e.forEach(t),r=e=>e.length,d=e=>0==r(e),c=e=>e.slice(1),l=e=>null==e,i=(e,t,s)=>l(e)?s?.():t(e),a=(e,t)=>e?.has(t)??!1,u=e=>l(e)||0==(e=>e.size)(e),g=e=>e.clear(),I=(e,t)=>e?.forEach(t),f=(e,t)=>e?.delete(t),h=e=>new Map(e),w=e=>[...e?.keys()??[]],p=(e,t)=>e?.get(t),L=(e,t)=>I(e,((e,s)=>t(s,e))),S=(e,t,s)=>l(s)?(f(e,t),e):e?.set(t,s),v=(e,t,s,n)=>(a(e,t)||(n?.(s),e.set(t,s)),p(e,t)),R=e=>new Set(e),b=(e,t)=>e?.add(t),x=(s,n)=>e(s)==t?e=>e(s):s??(()=>n??""),y=(e,t)=>e<t?-1:1,T=(e,t,s)=>r(s)<2?b(d(s)?e:v(e,s[0],R()),t):T(v(e,s[0],h()),t,c(s)),k=e=>{const t=(s,n,...r)=>i(s,(s=>d(r)?e(s,n):o([r[0],null],(e=>t(p(s,e),n,...c(r))))));return t},z=Object.freeze,D=(e=>{const t=new WeakMap;return s=>(t.has(s)||t.set(s,e(s)),t.get(s))})((e=>{const t=h(),d=h(),[c,v,D,E,M,j,C,O]=((e,t,s)=>{const n=e.hasRow,r=h(),d=h(),c=h(),u=h(),f=h(),v=t=>i(p(f,t),(s=>{I(s,e.delListener),S(f,t)})),b=e=>{S(r,e),S(d,e),S(c,e),S(u,e),v(e)};return[()=>e,()=>w(r),e=>p(r,e),e=>p(d,e),(e,t)=>S(d,e,t),(i,w,b,x,y)=>{const T=h(),k=h();S(r,i,w),a(d,i)||(S(d,i,t()),S(c,i,h()),S(u,i,h()));const z=p(c,i),D=p(u,i),E=t=>{const o=s=>e.getCell(w,t,s),r=p(z,t),d=n(w,t)?s(x(o,t)):void 0;if(r!=d&&S(T,t,[r,d]),!l(y)){const e=p(D,t),s=n(w,t)?y(o,t):void 0;e!=s&&S(k,t,s)}},M=e=>{b((()=>{I(T,(([,e],t)=>S(z,t,e))),I(k,((e,t)=>S(D,t,e)))}),T,k,z,D,e),g(T),g(k)};L(z,E),e.hasTable(w)&&o(e.getRowIds(w),(e=>{a(z,e)||E(e)})),M(!0),v(i),S(f,i,R([e.addRowListener(w,null,((e,t,s)=>E(s))),e.addTableListener(w,(()=>M()))]))},b,()=>L(f,b)]})(e,h,(e=>l(e)?"":e+"")),[W,m,q]=(e=>{let t,s=0;const n=[],d=h();return[(o,r,c=[])=>{t??=e();const l=n.pop()??""+s++;return S(d,l,[o,r,c]),T(r,l,c),l},(e,s=[],...n)=>k(I)(e,(e=>i(p(d,e),(([e])=>e(t,...s,...n)))),...s),e=>i(p(d,e),(([,t,s])=>(k(f)(t,e,...s),S(d,e),r(n)<1e3&&n.push(e),s)),(()=>[])),(e,s,n)=>i(p(d,e),(([e,,d])=>{const c=(...i)=>{const a=r(i);a==r(d)?e(t,...i,...n(i)):l(d[a])?o(s[a](...i),(e=>c(...i,e))):c(...i,d[a])};c()}))]})((()=>A)),A={setIndexDefinition:(e,o,r,c,g,w=y)=>{const v=l(g)?void 0:([e],[t])=>g(e,t);return j(e,o,((o,r,g,x,y,T)=>{let k=0;const z=R(),D=R(),j=E(e);if(I(r,(([e,t],s)=>{l(e)||(b(z,e),i(p(j,e),(t=>{f(t,s),u(t)&&(S(j,e),k=1)}))),l(t)||(b(z,t),a(j,t)||(S(j,t,R()),k=1),b(p(j,t),s),l(c)||b(D,t))})),o(),u(y)||(T?L(j,(e=>b(D,e))):L(g,(e=>i(p(x,e),(e=>b(D,e))))),I(D,(e=>{const t=(t,s)=>w(p(y,t),p(y,s),e),o=[...p(j,e)];s(o,t)||(S(j,e,R(n(o,t))),b(z,e))}))),(k||T)&&!l(v)){const t=[...j];s(t,v)||(M(e,h(n(t,v))),k=1)}k&&m(t,[e]),I(z,(t=>m(d,[e,t])))}),x(r),i(c,x)),A},delIndexDefinition:e=>(C(e),A),getStore:c,getIndexIds:v,getTableId:D,getSliceIds:e=>w(E(e)),getSliceRowIds:(e,t)=>[...p(E(e),t)?.values()??[]],addSliceIdsListener:(e,s)=>W(s,t,[e]),addSliceRowIdsListener:(e,t,s)=>W(s,d,[e,t]),delListener:e=>(q(e),A),destroy:O,getListenerStats:()=>({})};return z(A)}));export{D as createIndexes};
+const e=e=>typeof e,t=e(""),s=(e,t)=>e.every(((s,n)=>0==n||t(e[n-1],s)<=0)),n=(e,t)=>e.sort(t),o=(e,t)=>e.forEach(t),r=e=>e.length,c=e=>0==r(e),d=e=>e.slice(1),l=e=>null==e,i=(e,t,s)=>l(e)?s?.():t(e),a=(e,t)=>e?.has(t)??!1,h=e=>l(e)||0==(e=>e.size)(e),u=e=>e.clear(),I=(e,t)=>e?.forEach(t),f=(e,t)=>e?.delete(t),g=e=>new Map(e),S=e=>[...e?.keys()??[]],w=(e,t)=>e?.get(t),p=(e,t)=>I(e,((e,s)=>t(s,e))),L=(e,t,s)=>l(s)?(f(e,t),e):e?.set(t,s),x=(e,t,s,n)=>(a(e,t)||(n?.(s),e.set(t,s)),w(e,t)),v=e=>new Set(e),E=(e,t)=>e?.add(t),R=(s,n)=>e(s)==t?e=>e(s):s??(()=>n??""),b=(e,t)=>e<t?-1:1,y=(e,t,s)=>r(s)<2?E(c(s)?e:x(e,s[0],v()),t):y(x(e,s[0],g()),t,d(s)),T=e=>{const t=(s,n,...r)=>i(s,(s=>c(r)?e(s,n):o([r[0],null],(e=>t(w(s,e),n,...d(r))))));return t},k=Object.freeze,z=(e=>{const t=new WeakMap;return s=>(t.has(s)||t.set(s,e(s)),t.get(s))})((e=>{const t=g(),c=g(),[d,x,z,C,D,M,j,O,W,m]=((e,t,s)=>{const n=e.hasRow,r=g(),c=g(),d=g(),h=g(),f=g(),x=t=>i(w(f,t),(s=>{I(s,e.delListener),L(f,t)})),E=e=>{L(r,e),L(c,e),L(d,e),L(h,e),x(e)};return[()=>e,()=>S(r),e=>p(c,e),e=>a(c,e),e=>w(r,e),e=>w(c,e),(e,t)=>L(c,e,t),(i,S,E,R,b)=>{const y=g(),T=g();L(r,i,S),a(c,i)||(L(c,i,t()),L(d,i,g()),L(h,i,g()));const k=w(d,i),z=w(h,i),C=t=>{const o=s=>e.getCell(S,t,s),r=w(k,t),c=n(S,t)?s(R(o,t)):void 0;if(r!=c&&L(y,t,[r,c]),!l(b)){const e=w(z,t),s=n(S,t)?b(o,t):void 0;e!=s&&L(T,t,s)}},D=e=>{E((()=>{I(y,(([,e],t)=>L(k,t,e))),I(T,((e,t)=>L(z,t,e)))}),y,T,k,z,e),u(y),u(T)};p(k,C),e.hasTable(S)&&o(e.getRowIds(S),(e=>{a(k,e)||C(e)})),D(!0),x(i),L(f,i,v([e.addRowListener(S,null,((e,t,s)=>C(s))),e.addTableListener(S,(()=>D()))]))},E,()=>p(f,E)]})(e,g,(e=>l(e)?"":e+"")),[q,A,B]=(e=>{let t,s=0;const n=[],c=g();return[(o,r,d=[])=>{t??=e();const l=n.pop()??""+s++;return L(c,l,[o,r,d]),y(r,l,d),l},(e,s=[],...n)=>T(I)(e,(e=>i(w(c,e),(([e])=>e(t,...s,...n)))),...s),e=>i(w(c,e),(([,t,s])=>(T(f)(t,e,...s),L(c,e),r(n)<1e3&&n.push(e),s)),(()=>[])),(e,s,n)=>i(w(c,e),(([e,,c])=>{const d=(...i)=>{const a=r(i);a==r(c)?e(t,...i,...n(i)):l(c[a])?o(s[a](...i),(e=>d(...i,e))):d(...i,c[a])};d()}))]})((()=>G)),F=(t,s,n)=>{const o=D(t);I(n,((t,n)=>s(n,(s=>I(t,(t=>s(t,(s=>e.forEachCell(o,t,s)))))))))},G={setIndexDefinition:(e,o,r,d,u,S=b)=>{const x=l(u)?void 0:([e],[t])=>u(e,t);return O(e,o,((o,r,u,R,b,y)=>{let T=0;const k=v(),z=v(),C=M(e);if(I(r,(([e,t],s)=>{l(e)||(E(k,e),i(w(C,e),(t=>{f(t,s),h(t)&&(L(C,e),T=1)}))),l(t)||(E(k,t),a(C,t)||(L(C,t,v()),T=1),E(w(C,t),s),l(d)||E(z,t))})),o(),h(b)||(y?p(C,(e=>E(z,e))):p(u,(e=>i(w(R,e),(e=>E(z,e))))),I(z,(e=>{const t=(t,s)=>S(w(b,t),w(b,s),e),o=[...w(C,e)];s(o,t)||(L(C,e,v(n(o,t))),E(k,e))}))),(T||y)&&!l(x)){const t=[...C];s(t,x)||(j(e,g(n(t,x))),T=1)}T&&A(t,[e]),I(k,(t=>A(c,[e,t])))}),R(r),i(d,R)),G},delIndexDefinition:e=>(W(e),G),getStore:d,getIndexIds:x,forEachIndex:e=>z(((t,s)=>e(t,(e=>F(t,e,s))))),forEachSlice:(e,t)=>F(e,t,M(e)),hasIndex:C,hasSlice:(e,t)=>a(M(e),t),getTableId:D,getSliceIds:e=>S(M(e)),getSliceRowIds:(e,t)=>[...w(M(e),t)?.values()??[]],addSliceIdsListener:(e,s)=>q(s,t,[e]),addSliceRowIdsListener:(e,t,s)=>q(s,c,[e,t]),delListener:e=>(B(e),G),destroy:m,getListenerStats:()=>({})};return k(G)}));export{z as createIndexes};