tinybase 4.3.23 → 4.4.0-beta.1

package/lib/types/store.d.ts

@@ -529,9 +529,26 @@ export type TransactionListener = (
   getTransactionLog: GetTransactionLog,
 ) => void;
 
+/**
+ * The HasTablesListener type describes a function that is used to listen to
+ * Tables as a whole being added to or removed from the Store.
+ *
+ * A HasTablesListener is provided when using the addHasTablesListener method.
+ * See that method for specific examples.
+ *
+ * When called, a HasTablesListener is given a reference to the Store. It is
+ * also given a flag to indicate whether Tables now exist (having not done
+ * previously), or do not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param hasTables Whether Tables now exist or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasTablesListener = (store: Store, hasTables: boolean) => void;
+
 /**
  * The TablesListener type describes a function that is used to listen to
- * changes to the whole Store.
+ * changes to the tabular part of the Store.
  *
  * A TablesListener is provided when using the addTablesListener method. See
  * that method for specific examples.
@@ -574,6 +591,29 @@ export type TableIdsListener = (
   getIdChanges: GetIdChanges | undefined,
 ) => void;
 
+/**
+ * The HasTableListener type describes a function that is used to listen to a
+ * Table being added to or removed from the Store.
+ *
+ * A HasTableListener is provided when using the addHasTableListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasTableListener is given a reference to the Store, and the Id
+ * of the Table that changed. It is also given a flag to indicate whether the
+ * Table now exists (having not done previously), or does not (having done so
+ * previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param hasTable Whether the Table now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasTableListener = (
+  store: Store,
+  tableId: Id,
+  hasTable: boolean,
+) => void;
+
 /**
  * The TableListener type describes a function that is used to listen to changes
  * to a Table.
@@ -622,6 +662,31 @@ export type TableCellIdsListener = (
   getIdChanges: GetIdChanges | undefined,
 ) => void;
 
+/**
+ * The HasTableCellListener type describes a function that is used to listen to
+ * a Cell being added to or removed from a Table as a whole.
+ *
+ * A HasTableCellListener is provided when using the addHasTableCellListener
+ * method. See that method for specific examples.
+ *
+ * When called, a HasTableCellListener is given a reference to the Store, the Id
+ * of the Table that changed, and the Id of the Cell that changed. It is also
+ * given a flag to indicate whether the Cell now exists anywhere in the Table
+ * (having not done previously), or does not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param cellId The Id of the Table Cell that changed.
+ * @param hasTableCell Whether the Cell now exists anywhere in the Table or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasTableCellListener = (
+  store: Store,
+  tableId: Id,
+  cellId: Id,
+  hasTableCell: boolean,
+) => void;
+
 /**
  * The RowCountListener type describes a function that is used to listen to
  * changes to the number of Row objects in a Table.
@@ -700,6 +765,31 @@ export type SortedRowIdsListener = (
   sortedRowIds: Ids,
 ) => void;
 
+/**
+ * The HasRowListener type describes a function that is used to listen to a Row
+ * being added to or removed from the Store.
+ *
+ * A HasRowListener is provided when using the addHasRowListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasRowListener is given a reference to the Store, the Id of
+ * the Table that changed, and the Id of the Row that changed. It is also given
+ * a flag to indicate whether the Row now exists (having not done previously),
+ * or does not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param rowId The Id of the Row that changed.
+ * @param hasRow Whether the Row now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasRowListener = (
+  store: Store,
+  tableId: Id,
+  rowId: Id,
+  hasRow: boolean,
+) => void;
+
 /**
  * The RowListener type describes a function that is used to listen to changes
  * to a Row.
@@ -755,6 +845,33 @@ export type CellIdsListener = (
   getIdChanges: GetIdChanges | undefined,
 ) => void;
 
+/**
+ * The HasCellListener type describes a function that is used to listen to a
+ * Cell being added to or removed from the Store.
+ *
+ * A HasCellListener is provided when using the addHasCellListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasCellListener is given a reference to the Store, the Id of
+ * the Table that changed, the Id of the Row that changed, and the Id of Cell
+ * that changed. It is also given a flag to indicate whether the Cell now exists
+ * (having not done previously), or does not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param tableId The Id of the Table that changed.
+ * @param rowId The Id of the Row that changed.
+ * @param cellId The Id of the Cell that changed.
+ * @param hasCell Whether the Cell now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasCellListener = (
+  store: Store,
+  tableId: Id,
+  rowId: Id,
+  cellId: Id,
+  hasCell: boolean,
+) => void;
+
 /**
  * The CellListener type describes a function that is used to listen to changes
  * to a Cell.
@@ -792,6 +909,23 @@ export type CellListener = (
   getCellChange: GetCellChange | undefined,
 ) => void;
 
+/**
+ * The HasValuesListener type describes a function that is used to listen to
+ * Values as a whole being added to or removed from the Store.
+ *
+ * A HasValuesListener is provided when using the addHasValuesListener method.
+ * See that method for specific examples.
+ *
+ * When called, a HasValuesListener is given a reference to the Store. It is
+ * also given a flag to indicate whether Values now exist (having not done
+ * previously), or do not (having done so previously).
+ * @param store A reference to the Store that changed.
+ * @param hasValues Whether Values now exist or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasValuesListener = (store: Store, hasValues: boolean) => void;
+
 /**
  * The ValuesListener type describes a function that is used to listen to
  * changes to all the Values in a Store.
@@ -837,6 +971,29 @@ export type ValueIdsListener = (
   getIdChanges: GetIdChanges | undefined,
 ) => void;
 
+/**
+ * The HasValueListener type describes a function that is used to listen to a
+ * Value being added to or removed from the Store.
+ *
+ * A HasValueListener is provided when using the addHasValueListener method. See
+ * that method for specific examples.
+ *
+ * When called, a HasValueListener is given a reference to the Store and the Id
+ * of Value that changed. It is also given a flag to indicate whether the Value
+ * now exists (having not done previously), or does not (having done so
+ * previously).
+ * @param store A reference to the Store that changed.
+ * @param valueId The Id of the Value that changed.
+ * @param hasValue Whether the Value now exists or not.
+ * @category Listener
+ * @since v4.4.0
+ */
+export type HasValueListener = (
+  store: Store,
+  valueId: Id,
+  hasValue: boolean,
+) => void;
+
 /**
  * The ValueListener type describes a function that is used to listen to changes
  * to a Value.
@@ -1257,6 +1414,11 @@ export type GetTransactionLog = () => TransactionLog;
  * @category Development
  */
 export type StoreListenerStats = {
+  /**
+   * The number of HasTablesListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasTables?: number;
   /**
    * The number of TablesListener functions registered with the Store.
    */
@@ -1265,6 +1427,11 @@ export type StoreListenerStats = {
    * The number of TableIdsListener functions registered with the Store.
    */
   tableIds?: number;
+  /**
+   * The number of HasTableListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasTable?: number;
   /**
    * The number of TableListener functions registered with the Store.
    */
@@ -1274,6 +1441,11 @@ export type StoreListenerStats = {
    * since v3.3.
    */
   tableCellIds?: number;
+  /**
+   * The number of HasTableCellListener functions registered with the Store,
+   * since v4.4.
+   */
+  hasTableCell?: number;
   /**
    * The number of RowCountListener functions registered with the Store, since
    * v4.1.0
@@ -1287,6 +1459,11 @@ export type StoreListenerStats = {
    * The number of SortedRowIdsListener functions registered with the Store.
    */
   sortedRowIds?: number;
+  /**
+   * The number of HasRowListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasRow?: number;
   /**
    * The number of RowListener functions registered with the Store.
    */
@@ -1295,6 +1472,11 @@ export type StoreListenerStats = {
    * The number of CellIdsListener functions registered with the Store.
    */
   cellIds?: number;
+  /**
+   * The number of HasCellListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasCell?: number;
   /**
    * The number of CellListener functions registered with the Store.
    */
@@ -1303,6 +1485,11 @@ export type StoreListenerStats = {
    * The number of InvalidCellListener functions registered with the Store.
    */
   invalidCell?: number;
+  /**
+   * The number of HasValuesListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasValues?: number;
   /**
    * The number of ValuesListener functions registered with the Store, since
    * v3.0.
@@ -1313,6 +1500,11 @@ export type StoreListenerStats = {
    * v3.0.
    */
   valueIds?: number;
+  /**
+   * The number of HasValueListener functions registered with the Store, since
+   * v4.4.
+   */
+  hasValue?: number;
   /**
    * The number of ValueListener functions registered with the Store, since
    * v3.0.
@@ -1478,6 +1670,10 @@ export type StoreListenerStats = {
  * |Row|hasRow|forEachRow|
  * |Cell|hasCell|forEachCell|
  *
+ * Since v4.3.23, you can add listeners for the change of existence of part of a
+ * Store. For example, the addHasValueListener method lets you listen for a
+ * Value being added or removed.
+ *
  * Finally, the getListenerStats method describes the current state of the
  * Store's listeners for debugging purposes.
  * @example
@@ -3920,6 +4116,71 @@ export interface Store {
    */
   forEachValue(valueCallback: ValueCallback): void;
 
+  /**
+   * The addHasTablesListener method registers a listener function with the
+   * Store that will be called when Tables as a whole are added to or removed
+   * from the Store.
+   *
+   * The provided listener is a HasTablesListener function, and will be called
+   * with a reference to the Store. It is also given a flag to indicate whether
+   * Tables now exist (having not done previously), or do not (having done so
+   * previously).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param listener The function that will be called whenever Tables as a whole
+   * are added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to Tables being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTablesListener((store, hasTables) => {
+   *   console.log('Tables ' + (hasTables ? 'added' : 'removed'));
+   * });
+   *
+   * store.delTables();
+   * // -> 'Tables removed'
+   *
+   * store.setTables({species: {dog: {price: 5}}});
+   * // -> 'Tables added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to Tables being added or
+   * removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore();
+   * const listenerId = store.addHasTablesListener(
+   *   (store, hasTables) => store.setValue('hasTables', hasTables),
+   *   true,
+   * );
+   *
+   * store.setTables({species: {dog: {price: 5}}});
+   * console.log(store.getValues());
+   * // -> {hasTables: true}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasTablesListener(listener: HasTablesListener, mutator?: boolean): Id;
+
   /**
    * The addTablesListener method registers a listener function with the Store
    * that will be called whenever data in the Store changes.
@@ -4045,6 +4306,107 @@ export interface Store {
    */
   addTableIdsListener(listener: TableIdsListener, mutator?: boolean): Id;
 
+  /**
+   * The addHasTableListener method registers a listener function with the Store
+   * that will be called when a Table is added to or removed from the Store.
+   *
+   * The provided listener is a HasTableListener function, and will be called
+   * with a reference to the Store and the Id of the Table that changed. It is
+   * also given a flag to indicate whether the Table now exists (having not done
+   * previously), or does not (having done so previously).
+   *
+   * You can either listen to a single Table being added or removed (by
+   * specifying the Table Id as the method's first parameter) or changes to any
+   * Table (by providing a `null` wildcard).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching
+   * Table is added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Table being
+   * added or removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableListener(
+   *   'pets',
+   *   (store, tableId, hasTable) => {
+   *     console.log('pets table ' + (hasTable ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delTable('pets');
+   * // -> 'pets table removed'
+   *
+   * store.setTable('pets', {fido: {species: 'dog', color: 'brown'}});
+   * // -> 'pets table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Table being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableListener(
+   *   null,
+   *   (store, tableId, hasTable) => {
+   *     console.log(`${tableId} table ` + (hasTable ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delTable('pets');
+   * // -> 'pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'species table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Table being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableListener(
+   *   'pets',
+   *   (store, tableId) => store.setCell('meta', 'update', tableId, true),
+   *   true,
+   * );
+   *
+   * store.delTable('pets', 'fido');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasTableListener(
+    tableId: IdOrNull,
+    listener: HasTableListener,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addTableListener method registers a listener function with the Store
    * that will be called whenever data in a Table changes.
@@ -4246,16 +4608,24 @@ export interface Store {
   ): Id;
 
   /**
-   * The addRowCountListener method registers a listener function with the Store
-   * that will be called whenever the count of Row objects in a Table change.
+   * The addHasTableCellListener method registers a listener function with the
+   * Store that will be called when a Cell is added to or removed from anywhere
+   * in a Table as a whole.
    *
-   * The provided listener is a RowCountListener function, and will be called
-   * with a reference to the Store, the Id of the Table that changed, and the
-   * number of Row objects in the Table.
+   * The provided listener is a HasTableCellListener function, and will be
+   * called with a reference to the Store, the Id of the Table that changed, and
+   * the Id of the Table Cell that changed. It is also given a flag to indicate
+   * whether the Cell now exists anywhere in the Table (having not done
+   * previously), or does not (having done so previously).
    *
-   * You can either listen to a single Table (by specifying its Id as the
-   * method's first parameter) or changes to any Table (by providing a `null`
-   * wildcard).
+   * You can either listen to a single Table Cell being added or removed (by
+   * specifying the Table Id and Cell Id, as the method's first two parameters)
+   * or changes to any Table Cell (by providing `null` wildcards).
+   *
+   * Both, either, or neither of the `tableId` and `cellId` parameters can be
+   * wildcarded with `null`. You can listen to a specific Row in a specific
+   * Table, any Row in a specific Table, a specific Row in any Table, or any Row
+   * in any Table.
    *
    * Use the optional mutator parameter to indicate that there is code in the
    * listener that will mutate Store data. If set to `false` (or omitted), such
@@ -4265,53 +4635,164 @@ export interface Store {
    * The changes made by mutator listeners do not fire other mutating listeners,
    * though they will fire non-mutator listeners.
    * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
-   * @param listener The function that will be called whenever the number of Row
-   * objects in the Table changes.
+   * @param cellId The Id of the Cell to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching Cell
+   * is added to or removed from anywhere in the Table.
    * @param mutator An optional boolean that indicates that the listener mutates
    * Store data.
    * @returns A unique Id for the listener that can later be used to call it
    * explicitly, or to remove it.
    * @example
-   * This example registers a listener that responds to a change in the number
-   * of Row objects in a specific Table.
+   * This example registers a listener that responds to a specific Cell being
+   * added to or removed from the Table as a whole.
    *
    * ```js
-   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
-   * const listenerId = store.addRowCountListener(
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableCellListener(
    *   'pets',
-   *   (store, _tableId, count) => {
-   *     console.log('Row count for pets table changed to ' + count);
+   *   'color',
+   *   (store, tableId, cellId, hasTableCell) => {
+   *     console.log(
+   *       'color cell in pets table ' + (hasTableCell ? 'added' : 'removed'),
+   *     );
    *   },
    * );
    *
-   * store.setRow('pets', 'felix', {species: 'cat'});
-   * // -> 'Row count for pets table changed to 2'
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in pets table removed'
+   *
+   * store.setRow('pets', 'felix', {species: 'cat', color: 'brown'});
+   * // -> 'color cell in pets table added'
    *
    * store.delListener(listenerId);
    * ```
    * @example
-   * This example registers a listener that responds to any change to a change
-   * in the number of Row objects of any Table.
+   * This example registers a listener that responds to any Cell being
+   * added to or removed from the Table as a whole.
    *
    * ```js
-   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
-   * const listenerId = store.addRowCountListener(
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableCellListener(
    *   null,
-   *   (store, tableId, count) => {
-   *     console.log(`Row count for ${tableId} table changed to ${count}`);
+   *   null,
+   *   (store, tableId, cellId, hasTableCell) => {
+   *     console.log(
+   *       `${cellId} cell in ${tableId} table ` +
+   *         (hasTableCell ? 'added' : 'removed'),
+   *     );
    *   },
    * );
    *
-   * store.setRow('pets', 'felix', {species: 'cat'});
-   * // -> 'Row count for pets table changed to 2'
-   * store.setRow('species', 'dog', {price: 5});
-   * // -> 'Row count for species table changed to 1'
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'price cell in species table added'
    *
    * store.delListener(listenerId);
    * ```
    * @example
-   * This example registers a listener that responds to any change to a change
-   * in the number of Row objects of a specific Table, and which also mutates
+   * This example registers a listener that responds to a specific Cell being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasTableCellListener(
+   *   'pets',
+   *   'color',
+   *   (store, tableId, cellId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${cellId}`, true),
+   *   true,
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_color: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasTableCellListener(
+    tableId: IdOrNull,
+    cellId: IdOrNull,
+    listener: HasTableCellListener,
+    mutator?: boolean,
+  ): Id;
+
+  /**
+   * The addRowCountListener method registers a listener function with the Store
+   * that will be called whenever the count of Row objects in a Table change.
+   *
+   * The provided listener is a RowCountListener function, and will be called
+   * with a reference to the Store, the Id of the Table that changed, and the
+   * number of Row objects in the Table.
+   *
+   * You can either listen to a single Table (by specifying its Id as the
+   * method's first parameter) or changes to any Table (by providing a `null`
+   * wildcard).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the number of Row
+   * objects in the Table changes.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a change in the number
+   * of Row objects in a specific Table.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const listenerId = store.addRowCountListener(
+   *   'pets',
+   *   (store, _tableId, count) => {
+   *     console.log('Row count for pets table changed to ' + count);
+   *   },
+   * );
+   *
+   * store.setRow('pets', 'felix', {species: 'cat'});
+   * // -> 'Row count for pets table changed to 2'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any change to a change
+   * in the number of Row objects of any Table.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const listenerId = store.addRowCountListener(
+   *   null,
+   *   (store, tableId, count) => {
+   *     console.log(`Row count for ${tableId} table changed to ${count}`);
+   *   },
+   * );
+   *
+   * store.setRow('pets', 'felix', {species: 'cat'});
+   * // -> 'Row count for pets table changed to 2'
+   * store.setRow('species', 'dog', {price: 5});
+   * // -> 'Row count for species table changed to 1'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any change to a change
+   * in the number of Row objects of a specific Table, and which also mutates
    * the Store itself.
    *
    * ```js
@@ -4654,6 +5135,123 @@ export interface Store {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasRowListener method registers a listener function with the Store
+   * that will be called when a Row is added to or removed from the Store.
+   *
+   * The provided listener is a HasRowListener function, and will be called with
+   * a reference to the Store, the Id of the Table that changed, and the Id of
+   * the Row that changed. It is also given a flag to indicate whether the Row
+   * now exists (having not done previously), or does not (having done so
+   * previously).
+   *
+   * You can either listen to a single Row being added or removed (by specifying
+   * the Table Id and Row Id, as the method's first two parameters) or changes
+   * to any Row (by providing `null` wildcards).
+   *
+   * Both, either, or neither of the `tableId` and `rowId` parameters can be
+   * wildcarded with `null`. You can listen to a specific Row in a specific
+   * Table, any Row in a specific Table, a specific Row in any Table, or any Row
+   * in any Table.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching Row
+   * is added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Row being
+   * added or removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasRowListener(
+   *   'pets',
+   *   'fido',
+   *   (store, tableId, rowId, hasRow) => {
+   *     console.log(
+   *       'fido row in pets table ' + (hasRow ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * // -> 'fido row in pets table removed'
+   *
+   * store.setRow('pets', 'fido', {species: 'dog', color: 'brown'});
+   * // -> 'fido row in pets table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Row being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasRowListener(
+   *   null,
+   *   null,
+   *   (store, tableId, rowId, hasRow) => {
+   *     console.log(
+   *       `${rowId} row in ${tableId} table ` + (hasRow ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * // -> 'fido row in pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'dog row in species table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Row being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasRowListener(
+   *   'pets',
+   *   'fido',
+   *   (store, tableId, rowId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${rowId}`, true),
+   *   true,
+   * );
+   *
+   * store.delRow('pets', 'fido');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_fido: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasRowListener(
+    tableId: IdOrNull,
+    rowId: IdOrNull,
+    listener: HasRowListener,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addRowListener method registers a listener function with the Store that
    * will be called whenever data in a Row changes.
@@ -4868,6 +5466,130 @@ export interface Store {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasCellListener method registers a listener function with the Store
+   * that will be called when a Cell is added to or removed from the Store.
+   *
+   * The provided listener is a HasCellListener function, and will be called
+   * with a reference to the Store, the Id of the Table that changed, the Id of
+   * the Row that changed, and the Id of the Cell that changed. It is also given
+   * a flag to indicate whether the Cell now exists (having not done
+   * previously), or does not (having done so previously).
+   *
+   * You can either listen to a single Cell being added or removed (by
+   * specifying the Table Id, Row Id, and Cell Id as the method's first three
+   * parameters) or changes to any Cell (by providing `null` wildcards).
+   *
+   * All, some, or none of the `tableId`, `rowId`, and `cellId` parameters can
+   * be wildcarded with `null`. You can listen to a specific Cell in a specific
+   * Row in a specific Table, any Cell in any Row in any Table, for example - or
+   * every other combination of wildcards.
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param tableId The Id of the Table to listen to, or `null` as a wildcard.
+   * @param rowId The Id of the Row to listen to, or `null` as a wildcard.
+   * @param cellId The Id of the Cell to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching Cell
+   * is added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Cell being
+   * added or removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasCellListener(
+   *   'pets',
+   *   'fido',
+   *   'color',
+   *   (store, tableId, rowId, cellId, hasCell) => {
+   *     console.log(
+   *       'color cell in fido row in pets table ' +
+   *         (hasCell ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in fido row in pets table removed'
+   *
+   * store.setCell('pets', 'fido', 'color', 'walnut');
+   * // -> 'color cell in fido row in pets table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Cell being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasCellListener(
+   *   null,
+   *   null,
+   *   null,
+   *   (store, tableId, rowId, cellId, hasCell) => {
+   *     console.log(
+   *       `${cellId} cell in ${rowId} row in ${tableId} table ` +
+   *         (hasCell ? 'added' : 'removed'),
+   *     );
+   *   },
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * // -> 'color cell in fido row in pets table removed'
+   * store.setTable('species', {dog: {price: 5}});
+   * // -> 'price cell in dog row in species table added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Cell being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setTables({
+   *   pets: {fido: {species: 'dog', color: 'brown'}},
+   * });
+   * const listenerId = store.addHasCellListener(
+   *   'pets',
+   *   'fido',
+   *   'color',
+   *   (store, tableId, rowId, cellId) =>
+   *     store.setCell('meta', 'update', `${tableId}_${rowId}_${cellId}`, true),
+   *   true,
+   * );
+   *
+   * store.delCell('pets', 'fido', 'color');
+   * console.log(store.getTable('meta'));
+   * // -> {update: {pets_fido_color: true}}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasCellListener(
+    tableId: IdOrNull,
+    rowId: IdOrNull,
+    cellId: IdOrNull,
+    listener: HasCellListener,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addCellListener method registers a listener function with the Store
    * that will be called whenever data in a Cell changes.
@@ -4987,6 +5709,69 @@ export interface Store {
     mutator?: boolean,
   ): Id;
 
+  /**
+   * The addHasValuesListener method registers a listener function with the
+   * Store that will be called when Values as a whole are added to or removed
+   * from the Store.
+   *
+   * The provided listener is a HasValuesListener function, and will be called
+   * with a reference to the Store. It is also given a flag to indicate whether
+   * Values now exist (having not done previously), or do not (having done so
+   * previously).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param listener The function that will be called whenever Values as a whole
+   * are added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to Values being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValuesListener((store, hasValues) => {
+   *   console.log('Values ' + (hasValues ? 'added' : 'removed'));
+   * });
+   *
+   * store.delValues();
+   * // -> 'Values removed'
+   *
+   * store.setValue('employees', 4);
+   * // -> 'Values added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to Values being added or
+   * removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore();
+   * const listenerId = store.addHasValuesListener(
+   *   (store, hasValues) => store.setValue('hasValues', hasValues),
+   *   true,
+   * );
+   *
+   * store.setValue('employees', 4);
+   * console.log(store.getValues());
+   * // -> {employees: 4, hasValues: true}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasValuesListener(listener: HasValuesListener, mutator?: boolean): Id;
+
   /**
    * The addValuesListener method registers a listener function with the Store
    * that will be called whenever the Values change.
@@ -5110,6 +5895,101 @@ export interface Store {
    */
   addValueIdsListener(listener: ValueIdsListener, mutator?: boolean): Id;
 
+  /**
+   * The addHasValueListener method registers a listener function with the Store
+   * that will be called when a Value is added to or removed from the Store.
+   *
+   * The provided listener is a HasValueListener function, and will be called
+   * with a reference to the Store and the Id of Value that changed. It is also
+   * given a flag to indicate whether the Value now exists (having not done
+   * previously), or does not (having done so previously).
+   *
+   * You can either listen to a single Value being added or removed (by
+   * specifying the Value Id) or any Value being added or removed (by providing
+   * a `null` wildcard).
+   *
+   * Use the optional mutator parameter to indicate that there is code in the
+   * listener that will mutate Store data. If set to `false` (or omitted), such
+   * mutations will be silently ignored. All relevant mutator listeners (with
+   * this flag set to `true`) are called _before_ any non-mutator listeners
+   * (since the latter may become relevant due to changes made in the former).
+   * The changes made by mutator listeners do not fire other mutating listeners,
+   * though they will fire non-mutator listeners.
+   * @param valueId The Id of the Value to listen to, or `null` as a wildcard.
+   * @param listener The function that will be called whenever the matching
+   * Value is added or removed.
+   * @param mutator An optional boolean that indicates that the listener mutates
+   * Store data.
+   * @returns A unique Id for the listener that can later be used to call it
+   * explicitly, or to remove it.
+   * @example
+   * This example registers a listener that responds to a specific Value being
+   * added or removed.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValueListener(
+   *   'employees',
+   *   (store, valueId, hasValue) => {
+   *     console.log('employee value ' + (hasValue ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delValue('employees');
+   * // -> 'employee value removed'
+   *
+   * store.setValue('employees', 4);
+   * // -> 'employee value added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to any Value being added or
+   * removed.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValueListener(
+   *   null,
+   *   (store, valueId, hasValue) => {
+   *     console.log(valueId + ' value ' + (hasValue ? 'added' : 'removed'));
+   *   },
+   * );
+   *
+   * store.delValue('employees');
+   * // -> 'employees value removed'
+   * store.setValue('website', 'https://pets.com');
+   * // -> 'website value added'
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @example
+   * This example registers a listener that responds to a specific Value being
+   * added or removed, and which also mutates the Store itself.
+   *
+   * ```js
+   * const store = createStore().setValues({open: true, employees: 3});
+   * const listenerId = store.addHasValueListener(
+   *   'employees',
+   *   (store, valueId) => store.setValue('updated', true),
+   *   true,
+   * );
+   *
+   * store.delValue('employees');
+   * console.log(store.getValues());
+   * // -> {open: true, updated: true}
+   *
+   * store.delListener(listenerId);
+   * ```
+   * @category Listener
+   * @since v4.4.0
+   */
+  addHasValueListener(
+    valueId: IdOrNull,
+    listener: HasValueListener,
+    mutator?: boolean,
+  ): Id;
+
   /**
    * The addValueListener method registers a listener function with the Store
    * that will be called whenever data in a Value changes.