tinybase 4.5.0-beta.0 → 4.5.0

package/lib/types/persisters/persister-partykit-server.d.ts

@@ -18,8 +18,15 @@
  * @since 4.3.0
  */
 
-import {Cell, CellOrUndefined, Value, ValueOrUndefined} from '../store';
-import {Connection, Party, Request, Server} from 'partykit/server';
+import {
+  Cell,
+  CellOrUndefined,
+  Tables,
+  Value,
+  ValueOrUndefined,
+  Values,
+} from '../store';
+import {Connection, Party, Request, Server, Storage} from 'partykit/server';
 import {Id} from '../common';
 
 /**
@@ -517,3 +524,52 @@ export class TinyBasePartyKitServer implements Server {
    */
   canDelValue(valueId: Id, connection: Connection): boolean;
 }
+
+/**
+ * The hasStoreInStorage function returns a boolean indicating whether durable
+ * PartyKit storage contains a serialized Store.
+ *
+ * This is intended for specialist applications that require the ability to
+ * inspect or load a TinyBase Store from a server's storage outside of the
+ * normal context of a TinyBasePartyKitServer.
+ *
+ * The function is asynchronous, so you should use the `await` keyword or handle
+ * the result as a promise.
+ * @param storage A reference to the storage object, as would normally be
+ * accessible from the `TinyBasePartyKitServer.party` object.
+ * @param storagePrefix An optional prefix used before all the keys in the
+ * server's durable storage, to match the equivalent property in the server's
+ * TinyBasePartyKitServerConfig.
+ * @returns A promised boolean indicating whether a Store is present in the
+ * storage.
+ * @category Storage
+ * @since v4.4.1
+ */
+export function hasStoreInStorage(
+  storage: Storage,
+  storagePrefix?: string,
+): Promise<boolean>;
+
+/**
+ * The loadStoreFromStorage function returns the content of a Store from durable
+ * PartyKit storage.
+ *
+ * This is intended for specialist applications that require the ability to
+ * inspect or load a TinyBase Store from a server's storage outside of the
+ * normal context of a TinyBasePartyKitServer.
+ *
+ * The function is asynchronous, so you should use the `await` keyword or handle
+ * the result as a promise.
+ * @param storage A reference to the storage object, as would normally be
+ * accessible from the `TinyBasePartyKitServer.party` object.
+ * @param storagePrefix An optional prefix used before all the keys in the
+ * server's durable storage, to match the equivalent property in the server's
+ * TinyBasePartyKitServerConfig.
+ * @returns A promised array of a Tables object and a Values object.
+ * @category Storage
+ * @since v4.4.1
+ */
+export function loadStoreFromStorage(
+  storage: Storage,
+  storagePrefix?: string,
+): Promise<[Tables, Values]>;

package/lib/types/persisters/persister-remote.d.ts

@@ -55,8 +55,13 @@ export interface RemotePersister extends Persister {
  * the `POST` method (to send the Store JSON to save) respectively.
  *
  * For when you choose to enable automatic loading for the Persister (with the
- * startAutoLoad method), it will poll the loadUrl for changes. The
+ * startAutoLoad method), it will poll the loadUrl for changes, using the
+ * `ETag` HTTP header to identify if things have changed. The
  * `autoLoadIntervalSeconds` method is used to indicate how often to do this.
+ *
+ * If you are implementing the server portion of this functionality yourself,
+ * remember to ensure that the `ETag` header changes every time the server's
+ * Store content does - otherwise changes will not be detected by the client.
  * @param store The Store to persist.
  * @param loadUrl The endpoint that supports a `GET` method to load JSON.
  * @param saveUrl The endpoint that supports a `POST` method to save JSON.

package/lib/types/persisters.d.ts

@@ -19,6 +19,7 @@
  * |persister-sqlite-wasm|createSqliteWasmPersister|SQLite in a browser, via [sqlite-wasm](https://github.com/tomayac/sqlite-wasm)|
  * |persister-cr-sqlite-wasm|createCrSqliteWasmPersister|SQLite CRDTs, via [cr-sqlite-wasm](https://github.com/vlcn-io/cr-sqlite)|
  * |persister-expo-sqlite|createExpoSqlitePersister|SQLite in React Native, via [expo-sqlite](https://github.com/expo/expo/tree/main/packages/expo-sqlite)|
+ * |persister-expo-sqlite-next|createExpoSqliteNextPersister|SQLite in React Native, via [expo-sqlite/next](https://github.com/expo/expo/tree/main/packages/expo-sqlite/next)|
  * |persister-yjs|createYjsPersister|Yjs CRDTs, via [yjs](https://github.com/yjs/yjs)|
  * |persister-automerge|createSqliteWasmPersister|Automerge CRDTs, via [automerge-repo](https://github.com/automerge/automerge-repo)|
  *

package/lib/types/queries.d.ts

@@ -1313,49 +1313,6 @@ export type Where = {
  * ```js
  * const store = createStore()
  *   .setTable('pets', {
- *     fido: {species: 'dog', color: 'brown', owner: 'alice'},
- *     felix: {species: 'cat', color: 'black', owner: 'bob'},
- *     cujo: {species: 'dog', color: 'black', owner: 'bob'},
- *     lowly: {species: 'worm', color: 'brown', owner: 'alice'},
- *     carnaby: {species: 'parrot', color: 'black', owner: 'bob'},
- *     polly: {species: 'parrot', color: 'red', owner: 'alice'},
- *   })
- *   .setTable('species', {
- *     dog: {price: 5, legs: 4},
- *     cat: {price: 4, legs: 4},
- *     parrot: {price: 3, legs: 2},
- *     worm: {price: 1, legs: 0},
- *   });
- *
- * const queries = createQueries(store);
- * queries.setQueryDefinition('query', 'pets', ({select, join, group}) => {
- *   select('pets', 'color'); //    group by
- *   select('pets', 'owner'); //    group by
- *   select('species', 'price'); // grouped
- *   select('species', 'legs'); //  grouped
- *   // from pets
- *   join('species', 'species');
- *   group('price', 'avg').as('avgPrice');
- *   group('legs', 'sum').as('sumLegs');
- * });
- *
- * queries.forEachResultRow('query', (rowId) => {
- *   console.log({[rowId]: queries.getResultRow('query', rowId)});
- * });
- * // -> {0: {color: 'brown', owner: 'alice', avgPrice: 3, sumLegs: 4}}
- * // -> {1: {color: 'black', owner: 'bob', avgPrice: 4, sumLegs: 10}}
- * // -> {2: {color: 'red', owner: 'alice', avgPrice: 3, sumLegs: 2}}
- * ```
- * @example
- * This example shows a query that calculates the a custom aggregate of one
- * Cell's values, grouped by another. Note how `aggregateAdd`,
- * `aggregateRemove`, and `aggregateReplace` parameters are provided to make the
- * custom aggregation more efficient as individual values are added, removed, or
- * replaced during the lifecycle of the Table.
- *
- * ```js
- * const store = createStore()
- *   .setTable('pets', {
  *     fido: {species: 'dog', owner: 'alice'},
  *     felix: {species: 'cat', owner: 'bob'},
  *     cujo: {species: 'dog', owner: 'bob'},
@@ -1385,8 +1342,8 @@ export type Where = {
  *       remove == current
  *         ? undefined
  *         : add > 2
- *         ? Math.min(current, add)
- *         : current,
+ *           ? Math.min(current, add)
+ *           : current,
  *   ).as('lowestPriceOver2');
  * });
  *

package/lib/types/ui-react.d.ts

@@ -427,6 +427,59 @@ export function useStoreOrStoreById(
   storeOrStoreId?: StoreOrStoreId,
 ): Store | undefined;
 
+/**
+ * The useProvideStore hook is used to add a Store object by Id to a Provider
+ * component, but imperatively from a component within it.
+ *
+ * Normally you will register a Store by Id in a context by using the
+ * `storesById` prop of the top-level Provider component. This hook, however,
+ * lets you dynamically add a new Store to the context, from within a descendent
+ * component. This is useful for applications where the set of Stores is not
+ * known at the time of the first render of the root Provider.
+ *
+ * A Store added to the Provider context in this way will be available to other
+ * components within the context (using the useStore hook and so on). If you use
+ * the same Id as an existing Store registration, the new one will take priority
+ * over one provided by the `storesById` prop.
+ *
+ * Note that other components that consume a Store registered like this should
+ * defend against it being undefined at first. On the first render, the other
+ * component will likely not yet have completed the registration. In the example
+ * below, we use the null-safe `useStore('petStore')?.getTableIds()` to do this.
+ * @param storeId The Id of the Store object to be registered with the Provider.
+ * @param store The Store object to be registered.
+ * @example
+ * This example creates a Provider context. A child component registers a Store
+ * into it which is then consumable by a peer child component.
+ * ```jsx
+ * const App = () => (
+ *   <Provider>
+ *     <RegisterStore />
+ *     <ConsumeStore />
+ *   </Provider>
+ * );
+ * const RegisterStore = () => {
+ *   const store = useCreateStore(() =>
+ *     createStore().setCell('pets', 'fido', 'color', 'brown'),
+ *   );
+ *   useProvideStore('petStore', store);
+ *   return null;
+ * };
+ * const ConsumeStore = () => (
+ *   <span>{JSON.stringify(useStore('petStore')?.getTableIds())}</span>
+ * );
+ *
+ * const app = document.createElement('div');
+ * const root = ReactDOMClient.createRoot(app);
+ * root.render(<App />); // !act
+ * console.log(app.innerHTML);
+ * // -> '<span>["pets"]</span>'
+ * ```
+ * @category Store hooks
+ * @since v4.4.2
+ */
+export function useProvideStore(storeId: Id, store: Store): void;
+
 /**
  * The useHasTables hook returns a boolean indicating whether any Table objects
  * exist in the Store, and registers a listener so that any changes to that

package/lib/types/with-schemas/metrics.d.ts

@@ -413,8 +413,8 @@ export interface Metrics<in out Schemas extends OptionalSchemas> {
    *     remove == metric
    *       ? undefined
    *       : add > 2
-   *       ? Math.min(metric, add)
-   *       : metric,
+   *         ? Math.min(metric, add)
+   *         : metric,
    * );
    *
    * console.log(metrics.getMetric('lowestPriceOver2'));

package/lib/types/with-schemas/persisters/persister-expo-sqlite-next.d.ts

@@ -0,0 +1,181 @@
+/**
+ * The persister-expo-sqlite-next module of the TinyBase project lets you save
+ * and load Store data to and from a local Expo-SQLite 'next' database (in an
+ * appropriate React Native environment).
+ *
+ * This module provides a Persister for the modern version of Expo's
+ * [SQLite](https://docs.expo.dev/versions/latest/sdk/sqlite)
+ * library, designated 'next' as of November 2023. This API should be used if
+ * you are installing the `expo-sqlite/next` module. In the future we expect
+ * this module to become the default.
+ *
+ * Note that TinyBase support for the legacy version of Expo-SQLite
+ * (`expo-sqlite`) is still available in the persister-expo-sqlite module.
+ *
+ * Note that this Persister is currently experimental as Expo themselves iterate
+ * on the underlying database library API.
+ * @see Persisting Data guide
+ * @packageDocumentation
+ * @module persister-expo-sqlite-next
+ * @since v4.5.0
+ */
+
+import {DatabasePersisterConfig, Persister} from '../persisters';
+import {OptionalSchemas, Store} from '../store';
+import {Database} from 'expo-sqlite/next';
+
+/**
+ * The ExpoSqliteNextPersister interface is a minor extension to the Persister
+ * interface.
+ *
+ * It simply provides an extra getDb method for accessing a reference to the
+ * database instance the Store is being persisted to.
+ * @since v4.5.0
+ */
+export interface ExpoSqliteNextPersister<Schemas extends OptionalSchemas>
+  extends Persister<Schemas> {
+  /**
+   * The getDb method returns a reference to the database instance the Store is
+   * being persisted to.
+   * @returns A reference to the database instance.
+   * @example
+   * This example creates a Persister object against a newly-created Store and
+   * then gets the database instance back out again.
+   *
+   * ```js yolo
+   * const db = SQLite.openDatabaseSync('my.db');
+   * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+   * const persister = createExpoSqliteNextPersister(store, db, 'my_tinybase');
+   *
+   * console.log(persister.getDb() == db);
+   * // -> true
+   *
+   * persister.destroy();
+   * ```
+   * @category Getter
+   * @since v4.5.0
+   */
+  getDb: () => Database;
+}
+
+/**
+ * The createExpoSqliteNextPersister function creates a Persister object that
+ * can persist the Store to a local Expo-SQLite database (in an appropriate
+ * React Native environment).
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createExpoSqliteNextPersister(
+ *   store: Store,
+ *   db: Database,
+ *   configOrStoreTableName?: DatabasePersisterConfig | string,
+ *   onSqlCommand?: (sql: string, args?: any[]) => void,
+ *   onIgnoredError?: (error: any) => void,
+ * ): ExpoSqliteNextPersister;
+ * ```
+ *
+ * Note that this Persister is currently experimental as Expo themselves iterate
+ * on the underlying database library API.
+ *
+ * As well as providing a reference to the Store to persist, you must provide a
+ * `db` parameter which identifies the database instance.
+ *
+ * A database Persister uses one of two modes: either a JSON serialization of
+ * the whole Store stored in a single row of a table (the default), or a tabular
+ * mapping of Table Ids to database table names and vice-versa).
+ *
+ * The third argument is a DatabasePersisterConfig object that configures which
+ * of those modes to use, and settings for each. If the third argument is simply
+ * a string, it is used as the `storeTableName` property of the JSON
+ * serialization.
+ *
+ * See the documentation for the DpcJson and DpcTabular types for more
+ * information on how both of those modes can be configured.
+ * @param store The Store to persist.
+ * @param db The database instance that was returned from
+ * `SQLite.openDatabase(...)`.
+ * @param configOrStoreTableName A DatabasePersisterConfig to configure the
+ * persistence mode (or a string to set the `storeTableName` property of the
+ * JSON serialization).
+ * @param onSqlCommand An optional handler called every time the Persister
+ * executes a SQL command or query. This is suitable for logging persistence
+ * behavior in a development environment, since v4.0.4.
+ * @param onIgnoredError An optional handler for the errors that the Persister
+ * would otherwise ignore when trying to save or load data. This is suitable for
+ * debugging persistence issues in a development environment, since v4.0.4.
+ * @returns A reference to the new ExpoSqliteNextPersister object.
+ * @example
+ * This example creates a ExpoSqliteNextPersister object and persists the Store
+ * to a local SQLite database as a JSON serialization into the `my_tinybase`
+ * table. It makes a change to the database directly and then reloads it back
+ * into the Store.
+ *
+ * ```js yolo
+ * const db = SQLite.openDatabaseSync('my.db');
+ * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+ * const persister = createExpoSqliteNextPersister(store, db, 'my_tinybase');
+ *
+ * await persister.save();
+ * // Store will be saved to the database.
+ *
+ * console.log(
+ *   await new Promise((resolve) =>
+ *     db.allAsync('SELECT * FROM my_tinybase;').then(resolve),
+ *   ),
+ * );
+ * // -> [{_id: '_', store: '[{"pets":{"fido":{"species":"dog"}}},{}]'}]
+ *
+ * await new Promise((resolve) =>
+ *   db.allAsync(
+ *     'UPDATE my_tinybase SET store = ' +
+ *       `'[{"pets":{"felix":{"species":"cat"}}},{}]' WHERE _id = '_';`,
+ *   ),
+ * );
+ * await persister.load();
+ * console.log(store.getTables());
+ * // -> {pets: {felix: {species: 'cat'}}}
+ *
+ * persister.destroy();
+ * ```
+ * @example
+ * This example creates a ExpoSqliteNextPersister object and persists the Store
+ * to a local SQLite database with tabular mapping.
+ *
+ * ```js yolo
+ * const db = SQLite.openDatabaseSync('my.db');
+ * const store = createStore().setTables({pets: {fido: {species: 'dog'}}});
+ * const persister = createExpoSqliteNextPersister(store, db, {
+ *   mode: 'tabular',
+ *   tables: {load: {pets: 'pets'}, save: {pets: 'pets'}},
+ * });
+ *
+ * await persister.save();
+ * console.log(
+ *   await new Promise((resolve) =>
+ *     db.allAsync('SELECT * FROM pets;').then(resolve),
+ *   ),
+ * );
+ * // -> [{_id: 'fido', species: 'dog'}]
+ *
+ * await new Promise((resolve) =>
+ *   db
+ *     .allAsync(`INSERT INTO pets (_id, species) VALUES ('felix', 'cat')`)
+ *     .then(resolve),
+ * );
+ * await persister.load();
+ * console.log(store.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ *
+ * persister.destroy();
+ * ```
+ * @category Creation
+ * @since v4.5.0
+ */
+export function createExpoSqliteNextPersister<Schemas extends OptionalSchemas>(
+  store: Store<Schemas>,
+  db: Database,
+  configOrStoreTableName?: DatabasePersisterConfig<Schemas> | string,
+  onSqlCommand?: (sql: string, args?: any[]) => void,
+  onIgnoredError?: (error: any) => void,
+): ExpoSqliteNextPersister<Schemas>;

package/lib/types/with-schemas/persisters/persister-expo-sqlite.d.ts

@@ -3,6 +3,14 @@
  * load Store data to and from a local Expo-SQLite database (in an appropriate
  * React Native environment).
  *
+ * This module provides a Persister for the legacy version of Expo's
+ * [SQLite](https://docs.expo.dev/versions/latest/sdk/sqlite) library. This API
+ * should be used if you are installing the `expo-sqlite` module.
+ *
+ * Note that TinyBase support for the modern version of Expo-SQLite
+ * (`expo-sqlite-next`) is currently available in the persister-expo-sqlite-next
+ * module.
+ *
  * Note that this Persister is currently experimental as Expo themselves iterate
  * on the underlying database library API.
  * @see Persisting Data guide

package/lib/types/with-schemas/persisters/persister-partykit-server.d.ts

@@ -23,8 +23,11 @@ import {
   CellOrUndefined,
   NoTablesSchema,
   NoValuesSchema,
+  OptionalSchemas,
+  Tables,
   Value,
   ValueOrUndefined,
+  Values,
 } from '../store';
 import {Connection, Party, Request, Server} from 'partykit/server';
 import {Id} from '../common';
@@ -550,3 +553,61 @@ export class TinyBasePartyKitServer implements Server {
    */
   canDelValue(valueId: Id, connection: Connection): boolean;
 }
+
+/**
+ * The hasStoreInStorage function returns a boolean indicating whether durable
+ * PartyKit storage contains a serialized Store.
+ *
+ * This is intended for specialist applications that require the ability to
+ * inspect or load a TinyBase Store from a server's storage outside of the
+ * normal context of a TinyBasePartyKitServer.
+ *
+ * The function is asynchronous, so you should use the `await` keyword or handle
+ * the result as a promise.
+ * @param storage A reference to the storage object, as would normally be
+ * accessible from the `TinyBasePartyKitServer.party` object.
+ * @param storagePrefix An optional prefix used before all the keys in the
+ * server's durable storage, to match the equivalent property in the server's
+ * TinyBasePartyKitServerConfig.
+ * @returns A promised boolean indicating whether a Store is present in the
+ * storage.
+ * @category Storage
+ * @since v4.4.1
+ */
+export function hasStoreInStorage(
+  storage: Storage,
+  storagePrefix?: string,
+): Promise<boolean>;
+
+/**
+ * The loadStoreFromStorage function returns the content of a Store from durable
+ * PartyKit storage.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * loadStoreFromStorage(
+ *   storage: Storage,
+ *   storagePrefix?: string,
+ * ): Promise<[Tables, Values]>;
+ * ```
+ *
+ * This is intended for specialist applications that require the ability to
+ * inspect or load a TinyBase Store from a server's storage outside of the
+ * normal context of a TinyBasePartyKitServer.
+ *
+ * The function is asynchronous, so you should use the `await` keyword or handle
+ * the result as a promise.
+ * @param storage A reference to the storage object, as would normally be
+ * accessible from the `TinyBasePartyKitServer.party` object.
+ * @param storagePrefix An optional prefix used before all the keys in the
+ * server's durable storage, to match the equivalent property in the server's
+ * TinyBasePartyKitServerConfig.
+ * @returns A promised array of a Tables object and a Values object.
+ * @category Storage
+ * @since v4.4.1
+ */
+export function loadStoreFromStorage<Schemas extends OptionalSchemas>(
+  storage: Storage,
+  storagePrefix?: string,
+): Promise<[Tables<Schemas[0]>, Values<Schemas[1]>]>;

package/lib/types/with-schemas/persisters/persister-remote.d.ts

@@ -68,8 +68,13 @@ export interface RemotePersister<Schemas extends OptionalSchemas>
  * the `POST` method (to send the Store JSON to save) respectively.
  *
  * For when you choose to enable automatic loading for the Persister (with the
- * startAutoLoad method), it will poll the loadUrl for changes. The
+ * startAutoLoad method), it will poll the loadUrl for changes, using the
+ * `ETag` HTTP header to identify if things have changed. The
  * `autoLoadIntervalSeconds` method is used to indicate how often to do this.
+ *
+ * If you are implementing the server portion of this functionality yourself,
+ * remember to ensure that the `ETag` header changes every time the server's
+ * Store content does - otherwise changes will not be detected by the client.
  * @param store The Store to persist.
  * @param loadUrl The endpoint that supports a `GET` method to load JSON.
  * @param saveUrl The endpoint that supports a `POST` method to save JSON.

package/lib/types/with-schemas/persisters.d.ts

@@ -19,6 +19,7 @@
  * |persister-sqlite-wasm|createSqliteWasmPersister|SQLite in a browser, via [sqlite-wasm](https://github.com/tomayac/sqlite-wasm)|
  * |persister-cr-sqlite-wasm|createCrSqliteWasmPersister|SQLite CRDTs, via [cr-sqlite-wasm](https://github.com/vlcn-io/cr-sqlite)|
  * |persister-expo-sqlite|createExpoSqlitePersister|SQLite in React Native, via [expo-sqlite](https://github.com/expo/expo/tree/main/packages/expo-sqlite)|
+ * |persister-expo-sqlite-next|createExpoSqliteNextPersister|SQLite in React Native, via [expo-sqlite/next](https://github.com/expo/expo/tree/main/packages/expo-sqlite/next)|
  * |persister-yjs|createYjsPersister|Yjs CRDTs, via [yjs](https://github.com/yjs/yjs)|
  * |persister-automerge|createSqliteWasmPersister|Automerge CRDTs, via [automerge-repo](https://github.com/automerge/automerge-repo)|
  *

package/lib/types/with-schemas/queries.d.ts

@@ -1500,49 +1500,6 @@ export type Where<
  * ```js
  * const store = createStore()
  *   .setTable('pets', {
- *     fido: {species: 'dog', color: 'brown', owner: 'alice'},
- *     felix: {species: 'cat', color: 'black', owner: 'bob'},
- *     cujo: {species: 'dog', color: 'black', owner: 'bob'},
- *     lowly: {species: 'worm', color: 'brown', owner: 'alice'},
- *     carnaby: {species: 'parrot', color: 'black', owner: 'bob'},
- *     polly: {species: 'parrot', color: 'red', owner: 'alice'},
- *   })
- *   .setTable('species', {
- *     dog: {price: 5, legs: 4},
- *     cat: {price: 4, legs: 4},
- *     parrot: {price: 3, legs: 2},
- *     worm: {price: 1, legs: 0},
- *   });
- *
- * const queries = createQueries(store);
- * queries.setQueryDefinition('query', 'pets', ({select, join, group}) => {
- *   select('pets', 'color'); //    group by
- *   select('pets', 'owner'); //    group by
- *   select('species', 'price'); // grouped
- *   select('species', 'legs'); //  grouped
- *   // from pets
- *   join('species', 'species');
- *   group('price', 'avg').as('avgPrice');
- *   group('legs', 'sum').as('sumLegs');
- * });
- *
- * queries.forEachResultRow('query', (rowId) => {
- *   console.log({[rowId]: queries.getResultRow('query', rowId)});
- * });
- * // -> {0: {color: 'brown', owner: 'alice', avgPrice: 3, sumLegs: 4}}
- * // -> {1: {color: 'black', owner: 'bob', avgPrice: 4, sumLegs: 10}}
- * // -> {2: {color: 'red', owner: 'alice', avgPrice: 3, sumLegs: 2}}
- * ```
- * @example
- * This example shows a query that calculates the a custom aggregate of one
- * Cell's values, grouped by another. Note how `aggregateAdd`,
- * `aggregateRemove`, and `aggregateReplace` parameters are provided to make the
- * custom aggregation more efficient as individual values are added, removed, or
- * replaced during the lifecycle of the Table.
- *
- * ```js
- * const store = createStore()
- *   .setTable('pets', {
  *     fido: {species: 'dog', owner: 'alice'},
  *     felix: {species: 'cat', owner: 'bob'},
  *     cujo: {species: 'dog', owner: 'bob'},
@@ -1572,8 +1529,8 @@ export type Where<
  *       remove == current
  *         ? undefined
  *         : add > 2
- *         ? Math.min(current, add)
- *         : current,
+ *           ? Math.min(current, add)
+ *           : current,
  *   ).as('lowestPriceOver2');
  * });
  *

package/lib/types/with-schemas/store.d.ts

@@ -304,10 +304,10 @@ export type Cell<
 > = CellType extends 'string'
   ? string
   : CellType extends 'number'
-  ? number
-  : CellType extends 'boolean'
-  ? boolean
-  : string | number | boolean;
+    ? number
+    : CellType extends 'boolean'
+      ? boolean
+      : string | number | boolean;
 
 /**
  * The CellOrUndefined type is a data structure representing the data in a
@@ -400,10 +400,10 @@ export type Value<
 > = ValueType extends 'string'
   ? string
   : ValueType extends 'number'
-  ? number
-  : ValueType extends 'boolean'
-  ? boolean
-  : string | number | boolean;
+    ? number
+    : ValueType extends 'boolean'
+      ? boolean
+      : string | number | boolean;
 
 /**
  * The ValueOrUndefined type is a data structure representing the data in a