tinybase 8.0.0-beta.2 → 8.0.0-beta.3

package/@types/_internal/store/with-schemas/index.d.ts

@@ -48,7 +48,7 @@ export type CellIsDefaultedFromSchema<
   Then,
   Else,
 > = Schema[TableId][CellId] extends {
-  default: string | number | boolean;
+  default: infer _;
 }
   ? Then
   : Else;
@@ -83,7 +83,7 @@ export type ValueIsDefaultedFromSchema<
   Then,
   Else,
 > = Schema[ValueId] extends {
-  default: string | number | boolean;
+  default: infer _;
 }
   ? Then
   : Else;

package/@types/common/index.d.ts

@@ -16,6 +16,28 @@ import type {CellOrUndefined, ValueOrUndefined} from '../store/index.d.ts';
  */
 export type Json = string;
 
+/**
+ * The AnyObject type is a simple alias for a plain object with string keys and
+ * unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a plain
+ * JavaScript object, as can be stored in a Cell or Value with the `object`
+ * schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyObject = {[key: string]: unknown};
+
+/**
+ * The AnyArray type is a simple alias for an array with unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a JavaScript
+ * array, as can be stored in a Cell or Value with the `array` schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyArray = unknown[] | readonly unknown[];
+
 /**
  * The Ids type is a simple alias for an array of strings, but is used to
  * indicate that the strings should be considered to be the keys of objects

package/@types/common/with-schemas/index.d.ts

@@ -28,6 +28,28 @@ import type {
  */
 export type Json = string;
 
+/**
+ * The AnyObject type is a simple alias for a plain object with string keys and
+ * unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a plain
+ * JavaScript object, as can be stored in a Cell or Value with the `object`
+ * schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyObject = {[key: string]: unknown};
+
+/**
+ * The AnyArray type is a simple alias for an array with unknown values.
+ *
+ * It is used to indicate that the value should be considered to be a JavaScript
+ * array, as can be stored in a Cell or Value with the `array` schema type.
+ * @category General
+ * @since v8.0.0
+ */
+export type AnyArray = unknown[] | readonly unknown[];
+
 /**
  * The Ids type is a simple alias for an array of strings, but is used to
  * indicate that the strings should be considered to be the keys of objects

package/@types/middleware/index.d.ts

@@ -1072,8 +1072,10 @@ export interface Middleware {
    * const store = createStore();
    * const middleware = createMiddleware(store);
    *
-   * middleware.addDidSetRowCallback('pets', (_tableId, _rowId, oldRow, newRow) =>
-   *   'species' in newRow ? newRow : oldRow,
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, _rowId, oldRow, newRow) =>
+   *     'species' in newRow ? newRow : oldRow,
    * );
    *
    * store.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
@@ -1097,10 +1099,13 @@ export interface Middleware {
    * const middleware = createMiddleware(store);
    *
    * const seen = [];
-   * middleware.addDidSetRowCallback('pets', (_tableId, rowId, oldRow, newRow) => {
-   *   seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
-   *   return newRow;
-   * });
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, rowId, oldRow, newRow) => {
+   *     seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
+   *     return newRow;
+   *   },
+   * );
    *
    * store.transaction(() => {
    *   store.setCell('pets', 'fido', 'name', 'Fido');

package/@types/middleware/with-schemas/index.d.ts

@@ -1375,8 +1375,10 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * const store = createStore();
    * const middleware = createMiddleware(store);
    *
-   * middleware.addDidSetRowCallback('pets', (_tableId, _rowId, oldRow, newRow) =>
-   *   'species' in newRow ? newRow : oldRow,
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, _rowId, oldRow, newRow) =>
+   *     'species' in newRow ? newRow : oldRow,
    * );
    *
    * store.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
@@ -1400,10 +1402,13 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
    * const middleware = createMiddleware(store);
    *
    * const seen = [];
-   * middleware.addDidSetRowCallback('pets', (_tableId, rowId, oldRow, newRow) => {
-   *   seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
-   *   return newRow;
-   * });
+   * middleware.addDidSetRowCallback(
+   *   'pets',
+   *   (_tableId, rowId, oldRow, newRow) => {
+   *     seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
+   *     return newRow;
+   *   },
+   * );
    *
    * store.transaction(() => {
    *   store.setCell('pets', 'fido', 'name', 'Fido');

package/@types/store/index.d.ts

@@ -11,7 +11,14 @@
  * @since v1.0.0
  */
 import type {StoreAlias} from '../_internal/store/index.d.ts';
-import type {Id, IdOrNull, Ids, Json} from '../common/index.d.ts';
+import type {
+  AnyArray,
+  AnyObject,
+  Id,
+  IdOrNull,
+  Ids,
+  Json,
+} from '../common/index.d.ts';
 
 /**
  * The TablesSchema type describes the tabular structure of a Store in terms of
@@ -44,9 +51,13 @@ export type TablesSchema = {[tableId: Id]: {[cellId: Id]: CellSchema}};
  * The CellSchema type describes what values are allowed for each Cell in a
  * Table.
  *
- * A CellSchema specifies the type of the Cell (`string`, `boolean`, `number`;
- * or `null`, since v7.0), and what the default value can be when an explicit
- * value is not specified.
+ * A CellSchema specifies the type of the Cell (`string`, `boolean`, `number`,
+ * `null` since v7.0, or `object` or `array` since v8.0), and what the default
+ * value can be when an explicit value is not specified.
+ *
+ * For `object` and `array` types, TinyBase automatically serializes values to
+ * and from JSON when storing and retrieving them. This means you can set an
+ * object or array Cell directly, and get back the same structure.
  *
  * If a default value is provided (and its type is correct), you can be certain
  * that that Cell will always be present in a Row.
@@ -66,13 +77,27 @@ export type TablesSchema = {[tableId: Id]: {[cellId: Id]: CellSchema}};
  *   default: false,
  * };
  * ```
+ * @example
+ * When applied to a Store, this CellSchema allows an object Cell containing
+ * arbitrary data, defaulting to an empty object.
+ *
+ * ```js
+ * import type {CellSchema} from 'tinybase';
+ *
+ * export const tagsCell: CellSchema = {
+ *   type: 'object',
+ *   default: {},
+ * };
+ * ```
  * @category Schema
  * @since v1.0.0
  */
 export type CellSchema =
   | {type: 'string'; default?: string | null; allowNull?: boolean}
   | {type: 'number'; default?: number | null; allowNull?: boolean}
-  | {type: 'boolean'; default?: boolean | null; allowNull?: boolean};
+  | {type: 'boolean'; default?: boolean | null; allowNull?: boolean}
+  | {type: 'object'; default?: AnyObject; allowNull?: boolean}
+  | {type: 'array'; default?: AnyArray; allowNull?: boolean};
 
 /**
  * The ValuesSchema type describes the keyed Values that can be set in a Store
@@ -100,9 +125,12 @@ export type ValuesSchema = {[valueId: Id]: ValueSchema};
  * The ValueSchema type describes what values are allowed for keyed Values in a
  * Store.
  *
- * A ValueSchema specifies the type of the Value (`string`, `boolean`, `number`;
- * or `null` since v7.0), and what the default value can be when an explicit
- * value is not specified.
+ * A ValueSchema specifies the type of the Value (`string`, `boolean`, `number`,
+ * `null` since v7.0, or `object` or `array` since v8.0), and what the default
+ * value can be when an explicit value is not specified.
+ *
+ * For `object` and `array` types, TinyBase automatically serializes values to
+ * and from JSON when storing and retrieving them.
  *
  * If a default value is provided (and its type is correct), you can be certain
  * that the Value will always be present in a Store.
@@ -122,13 +150,27 @@ export type ValuesSchema = {[valueId: Id]: ValueSchema};
  *   default: false,
  * };
  * ```
+ * @example
+ * When applied to a Store, this ValueSchema allows an array Value containing
+ * a list of items, defaulting to an empty array.
+ *
+ * ```js
+ * import type {ValueSchema} from 'tinybase';
+ *
+ * export const cartItems: ValueSchema = {
+ *   type: 'array',
+ *   default: [],
+ * };
+ * ```
  * @category Schema
  * @since v3.0.0
  */
 export type ValueSchema =
   | {type: 'string'; default?: string | null; allowNull?: boolean}
   | {type: 'number'; default?: number | null; allowNull?: boolean}
-  | {type: 'boolean'; default?: boolean | null; allowNull?: boolean};
+  | {type: 'boolean'; default?: boolean | null; allowNull?: boolean}
+  | {type: 'object'; default?: AnyObject; allowNull?: boolean}
+  | {type: 'array'; default?: AnyArray; allowNull?: boolean};
 
 /**
  * The NoTablesSchema type is a TablesSchema-like type for when one has not been
@@ -280,7 +322,8 @@ export type Row = {[cellId: Id]: Cell};
  *
  * A Cell is used when setting a cell with the setCell method, and when getting
  * it back out again with the getCell method. A Cell is a JavaScript string,
- * number, boolean; or null since v7.0.
+ * number, boolean, or null (since v7.0), or a plain JavaScript object or array
+ * (since v8.0).
  * @example
  * ```js
  * import type {Cell} from 'tinybase';
@@ -290,7 +333,7 @@ export type Row = {[cellId: Id]: Cell};
  * @category Store
  * @since v1.0.0
  */
-export type Cell = string | number | boolean | null;
+export type Cell = string | number | boolean | null | AnyObject | AnyArray;
 
 /**
  * The CellOrUndefined type is a data structure representing the data in a
@@ -329,7 +372,8 @@ export type Values = {[valueId: Id]: Value};
  *
  * A Value is used when setting a value with the setValue method, and when
  * getting it back out again with the getValue method. A Value is a JavaScript
- * string, number, boolean; or null since v7.0.
+ * string, number, boolean, or null (since v7.0), or a plain JavaScript object
+ * or array (since v8.0).
  * @example
  * ```js
  * import type {Value} from 'tinybase';
@@ -339,7 +383,7 @@ export type Values = {[valueId: Id]: Value};
  * @category Store
  * @since v3.0.0
  */
-export type Value = string | number | boolean | null;
+export type Value = string | number | boolean | null | AnyObject | AnyArray;
 
 /**
  * The ValueOrUndefined type is a data structure representing the data in a
@@ -1389,8 +1433,8 @@ export type ChangedValues = {
  * transaction, primarily used so that you can indicate whether the transaction
  * should be rolled back.
  *
- * It provides both the old and new Values in a two-part array. These
- * describe the state of the changed Value in the Store at the _start_ of the
+ * It provides both the old and new Values in a two-part array. These describe
+ * the state of the changed Value in the Store at the _start_ of the
  * transaction, and by the _end_ of the transaction.
  *
  * Hence, an `undefined` value for the first item in the array means that the
@@ -1704,14 +1748,17 @@ export type StoreListenerStats = {
  *
  * The keyed value support is best thought of as a flat JavaScript object. The
  * Store contains a number of Value objects, each with a unique ID, and which is
- * a string, boolean, number; or null since v7.0.
+ * a string, boolean, number, null (since v7.0), or a plain JavaScript object or
+ * array (since v8.0).
  *
  * ```json
- * {                  // Store
- *   "value1": "one",   // Value (string)
- *   "value2": true,    // Value (boolean)
- *   "value3": 3,       // Value (number)
- *   "value4": null,    // Value (null since v7.0)
+ * {                           // Store
+ *   "value1": "one",            // Value (string)
+ *   "value2": true,             // Value (boolean)
+ *   "value3": 3,                // Value (number)
+ *   "value4": null,             // Value (null since v7.0)
+ *   "value5": {"x": 1},         // Value (object since v8.0)
+ *   "value6": [1, 2, 3],        // Value (array since v8.0)
  *   ...
  * }
  * ```
@@ -1728,7 +1775,8 @@ export type StoreListenerStats = {
  * - Each Table contains a number of Row objects.
  * - Each Row contains a number of Cell objects.
  *
- * A Cell is a string, boolean, number; or null since v7.0.
+ * A Cell is a string, boolean, number, null (since v7.0), or a plain JavaScript
+ * object or array (since v8.0).
  *
  * The members of each level of this hierarchy are identified with a unique Id
  * (which is a string). In other words you can naively think of a Store as a
@@ -1742,6 +1790,8 @@ export type StoreListenerStats = {
  *       "cell2": true,        // Cell (boolean)
  *       "cell3": 3,           // Cell (number)
  *       "cell4": null,        // Cell (null since v7.0)
+ *       "cell5": {"x": 1},    // Cell (object since v8.0)
+ *       "cell6": [1, 2, 3],   // Cell (array since v8.0)
  *       ...
  *     },
  *     ...
@@ -2988,7 +3038,10 @@ export interface Store {
    *   {open: true, employees: 3},
    * ]);
    *
-   * store.setContent([{pets: {felix: {species: 'cat', bug: []}}}, '']);
+   * store.setContent([
+   *   {pets: {felix: {species: 'cat', bug: new Date(0)}}},
+   *   '',
+   * ]);
    * console.log(store.getTables());
    * // -> {pets: {felix: {species: 'cat'}}}
    * console.log(store.getValues());
@@ -3044,7 +3097,7 @@ export interface Store {
    *
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    *
-   * store.setTables({pets: {felix: {species: 'cat', bug: []}}});
+   * store.setTables({pets: {felix: {species: 'cat', bug: new Date(0)}}});
    * console.log(store.getTables());
    * // -> {pets: {felix: {species: 'cat'}}}
    *
@@ -3100,7 +3153,7 @@ export interface Store {
    *
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    *
-   * store.setTable('pets', {felix: {species: 'cat', bug: []}});
+   * store.setTable('pets', {felix: {species: 'cat', bug: new Date(0)}});
    * console.log(store.getTables());
    * // -> {pets: {felix: {species: 'cat'}}}
    *
@@ -3154,7 +3207,7 @@ export interface Store {
    *
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    *
-   * store.setRow('pets', 'fido', {color: 'brown', bug: []});
+   * store.setRow('pets', 'fido', {color: 'brown', bug: new Date(0)});
    * console.log(store.getTables());
    * // -> {pets: {fido: {color: 'brown'}}}
    *
@@ -3219,7 +3272,7 @@ export interface Store {
    *
    * const store = createStore().setTables({pets: {'0': {species: 'dog'}}});
    *
-   * console.log(store.addRow('pets', {species: 'cat', bug: []}));
+   * console.log(store.addRow('pets', {species: 'cat', bug: new Date(0)}));
    * // -> '1'
    * console.log(store.getTables());
    * // -> {pets: {'0': {species: 'dog'}, '1': {species: 'cat'}}}
@@ -3278,7 +3331,7 @@ export interface Store {
    *
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    *
-   * store.setPartialRow('pets', 'fido', {color: 'brown', bug: []});
+   * store.setPartialRow('pets', 'fido', {color: 'brown', bug: new Date(0)});
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog', color: 'brown'}}}
    *
@@ -3301,10 +3354,10 @@ export interface Store {
    * does not match a TablesSchema associated with the Store), will be ignored
    * silently.
    *
-   * As well as string, number, or boolean Cell types, this method can also take
-   * a MapCell function that takes the current Cell value as a parameter and
-   * maps it. This is useful if you want to efficiently increment a value
-   * without fetching it first, for example.
+   * As well as string, number, boolean, null, object, and array Cell types,
+   * this method can also take a MapCell function that takes the current Cell
+   * value as a parameter and maps it. This is useful if you want to efficiently
+   * increment a value without fetching it first, for example.
    *
    * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
@@ -3346,7 +3399,7 @@ export interface Store {
    *
    * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
    *
-   * store.setCell('pets', 'fido', 'bug', []);
+   * store.setCell('pets', 'fido', 'bug', new Date(0));
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog'}}}
    * ```
@@ -3394,7 +3447,7 @@ export interface Store {
    *
    * const store = createStore().setValues({open: true});
    *
-   * store.setValues({employees: 3, bug: []});
+   * store.setValues({employees: 3, bug: new Date(0)});
    * console.log(store.getValues());
    * // -> {employees: 3}
    *
@@ -3447,7 +3500,7 @@ export interface Store {
    *
    * const store = createStore().setValues({open: true});
    *
-   * store.setPartialValues({employees: 3, bug: []});
+   * store.setPartialValues({employees: 3, bug: new Date(0)});
    * console.log(store.getValues());
    * // -> {open: true, employees: 3}
    *
@@ -3469,10 +3522,10 @@ export interface Store {
    * If the Value is invalid (either because of its type, or because it does not
    * match a ValuesSchema associated with the Store), will be ignored silently.
    *
-   * As well as string, number, or boolean Value types, this method can also
-   * take a MapValue function that takes the current Value as a parameter and
-   * maps it. This is useful if you want to efficiently increment a value
-   * without fetching it first, for example.
+   * As well as string, number, boolean, null, object, and array Value types,
+   * this method can also take a MapValue function that takes the current Value
+   * as a parameter and maps it. This is useful if you want to efficiently
+   * increment a value without fetching it first, for example.
    *
    * The method returns a reference to the Store so that subsequent operations
    * can be chained in a fluent style.
@@ -3510,7 +3563,7 @@ export interface Store {
    *
    * const store = createStore().setValues({employees: 3});
    *
-   * store.setValue('bug', []);
+   * store.setValue('bug', new Date(0));
    * console.log(store.getValues());
    * // -> {employees: 3}
    * ```
@@ -4246,10 +4299,10 @@ export interface Store {
    *   () =>
    *     store
    *       .setCell('pets', 'fido', 'color', 'black')
-   *       .setCell('pets', 'fido', 'eyes', ['left', 'right'])
-   *       .setCell('pets', 'fido', 'info', {sold: null})
+   *       .setCell('pets', 'fido', 'date0', new Date(0))
+   *       .setCell('pets', 'fido', 'date1', new Date(1))
    *       .setValue('open', false)
-   *       .setValue('employees', ['alice', 'bob']),
+   *       .setValue('date2', new Date(2)),
    *   () => {
    *     const [, , changedCells, invalidCells, changedValues, invalidValues] =
    *       store.getTransactionLog();
@@ -4263,9 +4316,9 @@ export interface Store {
    * );
    * // -> {pets: {fido: {species: 'dog', color: 'black'}}}
    * // -> {pets: {fido: {color: ['brown', 'black']}}}
-   * // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
+   * // -> {pets: {fido: {date0: [new Date(0)], date1: [new Date(1)]}}}
    * // -> {open: [true, false]}
-   * // -> {employees: [['alice', 'bob']]}
+   * // -> {date2: [new Date(2)]}
    *
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog', color: 'brown'}}}
@@ -4389,10 +4442,10 @@ export interface Store {
    * store
    *   .startTransaction()
    *   .setCell('pets', 'fido', 'color', 'black')
-   *   .setCell('pets', 'fido', 'eyes', ['left', 'right'])
-   *   .setCell('pets', 'fido', 'info', {sold: null})
+   *   .setCell('pets', 'fido', 'date0', new Date(0))
+   *   .setCell('pets', 'fido', 'date1', new Date(1))
    *   .setValue('open', false)
-   *   .setValue('employees', ['alice', 'bob'])
+   *   .setValue('date2', new Date(2))
    *   .finishTransaction(() => {
    *     const [, , changedCells, invalidCells, changedValues, invalidValues] =
    *       store.getTransactionLog();
@@ -4402,9 +4455,9 @@ export interface Store {
    *     console.log(invalidValues);
    *   });
    * // -> {pets: {fido: {color: ['brown', 'black']}}}
-   * // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
+   * // -> {pets: {fido: {date0: [new Date(0)], date1: [new Date(1)]}}}
    * // -> {open: [true, false]}
-   * // -> {employees: [['alice', 'bob']]}
+   * // -> {date2: [new Date(2)]}
    * ```
    * @category Transaction
    * @since v5.0.0
@@ -4482,10 +4535,10 @@ export interface Store {
    * store
    *   .startTransaction()
    *   .setCell('pets', 'fido', 'color', 'black')
-   *   .setCell('pets', 'fido', 'eyes', ['left', 'right'])
-   *   .setCell('pets', 'fido', 'info', {sold: null})
+   *   .setCell('pets', 'fido', 'date0', new Date(0))
+   *   .setCell('pets', 'fido', 'date1', new Date(1))
    *   .setValue('open', false)
-   *   .setValue('employees', ['alice', 'bob'])
+   *   .setValue('date2', new Date(2))
    *   .finishTransaction(() => {
    *     const [, , changedCells, invalidCells, changedValues, invalidValues] =
    *       store.getTransactionLog();
@@ -4498,9 +4551,9 @@ export interface Store {
    *   });
    * // -> {pets: {fido: {species: 'dog', color: 'black'}}}
    * // -> {pets: {fido: {color: ['brown', 'black']}}}
-   * // -> {pets: {fido: {eyes: [['left', 'right']], info: [{sold: null}]}}}
+   * // -> {pets: {fido: {date0: [new Date(0)], date1: [new Date(1)]}}}
    * // -> {open: [true, false]}
-   * // -> {employees: [['alice', 'bob']]}
+   * // -> {date2: [new Date(2)]}
    *
    * console.log(store.getTables());
    * // -> {pets: {fido: {species: 'dog', color: 'brown'}}}
@@ -6883,16 +6936,16 @@ export interface Store {
    * const listenerId = store.addInvalidCellListener(
    *   'pets',
    *   'fido',
-   *   'color',
+   *   'birth',
    *   (store, tableId, rowId, cellId, invalidCells) => {
-   *     console.log('Invalid color cell in fido row in pets table');
+   *     console.log('Invalid birth cell in fido row in pets table');
    *     console.log(invalidCells);
    *   },
    * );
    *
-   * store.setCell('pets', 'fido', 'color', {r: '96', g: '4B', b: '00'});
-   * // -> 'Invalid color cell in fido row in pets table'
-   * // -> [{r: '96', g: '4B', b: '00'}]
+   * store.setCell('pets', 'fido', 'birth', new Date(0));
+   * // -> 'Invalid birth cell in fido row in pets table'
+   * // -> [new Date(0)]
    *
    * store.delListener(listenerId);
    * ```
@@ -6919,10 +6972,10 @@ export interface Store {
    *   },
    * );
    *
-   * store.setCell('pets', 'fido', 'color', {r: '96', g: '4B', b: '00'});
-   * // -> 'Invalid color cell in fido row in pets table'
-   * store.setTable('sales', {fido: {date: new Date()}});
-   * // -> 'Invalid date cell in fido row in sales table'
+   * store.setCell('pets', 'fido', 'birth', new Date(0));
+   * // -> 'Invalid birth cell in fido row in pets table'
+   * store.setTable('sales', {fido: {birth: new Date()}});
+   * // -> 'Invalid birth cell in fido row in sales table'
    *
    * store.setRow('pets', 'felix', {});
    * // -> 'Invalid undefined cell in felix row in pets table'
@@ -7026,7 +7079,7 @@ export interface Store {
    * const listenerId = store.addInvalidCellListener(
    *   'pets',
    *   'fido',
-   *   'color',
+   *   'birth',
    *   (store, tableId, rowId, cellId, invalidCells) =>
    *     store.setCell(
    *       'meta',
@@ -7037,9 +7090,9 @@ export interface Store {
    *   true,
    * );
    *
-   * store.setCell('pets', 'fido', 'color', {r: '96', g: '4B', b: '00'});
+   * store.setCell('pets', 'fido', 'birth', new Date(0));
    * console.log(store.getRow('meta', 'invalid_updates'));
-   * // -> {'pets_fido_color': '{"r":"96","g":"4B","b":"00"}'}
+   * // -> {'pets_fido_birth': '"1970-01-01T00:00:00.000Z"'}
    *
    * store.delListener(listenerId);
    * ```
@@ -7108,16 +7161,16 @@ export interface Store {
    *
    * const store = createStore().setValues({open: true});
    * const listenerId = store.addInvalidValueListener(
-   *   'open',
+   *   'openDate',
    *   (store, valueId, invalidValues) => {
-   *     console.log('Invalid open value');
+   *     console.log('Invalid openDate value');
    *     console.log(invalidValues);
    *   },
    * );
    *
-   * store.setValue('open', {yes: true});
-   * // -> 'Invalid open value'
-   * // -> [{yes: true}]
+   * store.setValue('openDate', new Date(0));
+   * // -> 'Invalid openDate value'
+   * // -> [new Date(0)]
    *
    * store.delListener(listenerId);
    * ```
@@ -7137,10 +7190,10 @@ export interface Store {
    *   },
    * );
    *
-   * store.setValue('open', {yes: true});
-   * // -> 'Invalid open value'
-   * store.setValue('employees', ['alice', 'bob']);
-   * // -> 'Invalid employees value'
+   * store.setValue('openDate', new Date(0));
+   * // -> 'Invalid openDate value'
+   * store.setValue('closeDate', new Date(1));
+   * // -> 'Invalid closeDate value'
    *
    * store.setValues('pets', 'felix', {});
    * // -> 'Invalid undefined value'
@@ -7216,15 +7269,15 @@ export interface Store {
    *
    * const store = createStore().setValues({open: true});
    * const listenerId = store.addInvalidValueListener(
-   *   'open',
+   *   'openDate',
    *   (store, valueId, invalidValues) =>
    *     store.setValue('invalid_updates', JSON.stringify(invalidValues[0])),
    *   true,
    * );
    *
-   * store.setValue('open', {yes: true});
+   * store.setValue('openDate', new Date(0));
    * console.log(store.getValue('invalid_updates'));
-   * // -> '{"yes":true}'
+   * // -> '"1970-01-01T00:00:00.000Z"'
    *
    * store.delListener(listenerId);
    * ```