tinybase 8.6.0-beta.0 → 9.0.0-beta.1

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

@@ -12,8 +12,7 @@ import type {
 export type JoinedCellIdOrId<
   Schema extends OptionalTablesSchema = NoTablesSchema,
   JoinedTableId extends TableIdFromSchema<Schema> | Id =
-    | TableIdFromSchema<Schema>
-    | Id,
+    TableIdFromSchema<Schema> | Id,
 > =
   JoinedTableId extends TableIdFromSchema<Schema>
     ? CellIdFromSchema<Schema, JoinedTableId>

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

@@ -15,33 +15,25 @@ import type {
 import type {Synchronizer} from '../../../synchronizers/with-schemas/index.d.ts';
 
 export type StoreOrStoreId<Schemas extends OptionalSchemas> =
-  | Store<Schemas>
-  | Id;
+  Store<Schemas> | Id;
 
 export type MetricsOrMetricsId<Schemas extends OptionalSchemas> =
-  | Metrics<Schemas>
-  | Id;
+  Metrics<Schemas> | Id;
 
 export type IndexesOrIndexesId<Schemas extends OptionalSchemas> =
-  | Indexes<Schemas>
-  | Id;
+  Indexes<Schemas> | Id;
 
 export type RelationshipsOrRelationshipsId<Schemas extends OptionalSchemas> =
-  | Relationships<Schemas>
-  | Id;
+  Relationships<Schemas> | Id;
 
 export type QueriesOrQueriesId<Schemas extends OptionalSchemas> =
-  | Queries<Schemas>
-  | Id;
+  Queries<Schemas> | Id;
 
 export type CheckpointsOrCheckpointsId<Schemas extends OptionalSchemas> =
-  | Checkpoints<Schemas>
-  | Id;
+  Checkpoints<Schemas> | Id;
 
 export type PersisterOrPersisterId<Schemas extends OptionalSchemas> =
-  | Persister<Schemas, Persists.StoreOrMergeableStore>
-  | Id;
+  Persister<Schemas, Persists.StoreOrMergeableStore> | Id;
 
 export type SynchronizerOrSynchronizerId<Schemas extends OptionalSchemas> =
-  | Synchronizer<Schemas>
-  | Id;
+  Synchronizer<Schemas> | Id;

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

@@ -1097,19 +1097,19 @@ export interface MergeableStore extends Store {
  *         {
  *           fido: [
  *             {
- *               sold: [false, 'Nn1JUF----2FnHIC', 2603026204],
+ *               sold: [false, '', 3177411910],
  *               species: ['dog', 'Nn1JUF----1FnHIC', 2817056260],
  *             },
  *             '',
- *             2859424112,
+ *             3078067457,
  *           ],
  *         },
  *         '',
- *         1640515891,
+ *         1137907280,
  *       ],
  *     },
  *     '',
- *     2077041985,
+ *     401719767,
  *   ],
  *   [{}, '', 0],
  * ];

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

@@ -91,12 +91,14 @@ export type ContentHashes = [tablesHash: Hash, valuesHash: Hash];
 export type TablesStamp<
   Schema extends OptionalTablesSchema,
   Hashed extends boolean = false,
+  WhenSet extends boolean = false,
 > = Stamp<
   {
     [TableId in TableIdFromSchema<Schema>]?: TableStamp<
       Schema,
       TableId,
-      Hashed
+      Hashed,
+      WhenSet
     >;
   },
   Hashed
@@ -146,7 +148,8 @@ export type TableStamp<
   Schema extends OptionalTablesSchema,
   TableId extends TableIdFromSchema<Schema>,
   Hashed extends boolean = false,
-> = Stamp<{[rowId: Id]: RowStamp<Schema, TableId, Hashed>}, Hashed>;
+  WhenSet extends boolean = false,
+> = Stamp<{[rowId: Id]: RowStamp<Schema, TableId, Hashed, WhenSet>}, Hashed>;
 
 /**
  * The RowHashes type is used to quickly compare the content of two sets of Row
@@ -192,13 +195,15 @@ export type RowStamp<
   Schema extends OptionalTablesSchema,
   TableId extends TableIdFromSchema<Schema>,
   Hashed extends boolean = false,
+  WhenSet extends boolean = false,
 > = Stamp<
   {
     [CellId in CellIdFromSchema<Schema, TableId>]?: CellStamp<
       Schema,
       TableId,
       CellId,
-      Hashed
+      Hashed,
+      WhenSet
     >;
   },
   Hashed
@@ -251,7 +256,13 @@ export type CellStamp<
   TableId extends TableIdFromSchema<Schema>,
   CellId extends CellIdFromSchema<Schema, TableId>,
   Hashed extends boolean = false,
-> = Stamp<CellOrUndefined<Schema, TableId, CellId>, Hashed>;
+  WhenSet extends boolean = false,
+> = Stamp<
+  WhenSet extends true
+    ? CellOrUndefined<Schema, TableId, CellId>
+    : CellOrUndefined<Schema, TableId, CellId>,
+  Hashed
+>;
 
 /**
  * The ValuesStamp type is used as metadata to decide how to merge two different
@@ -274,12 +285,14 @@ export type CellStamp<
 export type ValuesStamp<
   Schema extends OptionalValuesSchema,
   Hashed extends boolean = false,
+  WhenSet extends boolean = false,
 > = Stamp<
   {
     [ValueId in ValueIdFromSchema<Schema>]?: ValueStamp<
       Schema,
       ValueId,
-      Hashed
+      Hashed,
+      WhenSet
     >;
   },
   Hashed
@@ -329,7 +342,13 @@ export type ValueStamp<
   Schema extends OptionalValuesSchema,
   ValueId extends ValueIdFromSchema<Schema>,
   Hashed extends boolean = false,
-> = Stamp<ValueOrUndefined<Schema, ValueId>, Hashed>;
+  WhenSet extends boolean = false,
+> = Stamp<
+  WhenSet extends true
+    ? ValueOrUndefined<Schema, ValueId>
+    : ValueOrUndefined<Schema, ValueId>,
+  Hashed
+>;
 
 /**
  * The MergeableContent type represents the content of a MergeableStore and the
@@ -352,9 +371,12 @@ export type ValueStamp<
  * @category Mergeable
  * @since v5.0.0
  */
-export type MergeableContent<Schemas extends OptionalSchemas> = [
-  mergeableTables: TablesStamp<Schemas[0], true>,
-  mergeableValues: ValuesStamp<Schemas[1], true>,
+export type MergeableContent<
+  Schemas extends OptionalSchemas,
+  WhenSet extends boolean = false,
+> = [
+  mergeableTables: TablesStamp<Schemas[0], true, WhenSet>,
+  mergeableValues: ValuesStamp<Schemas[1], true, WhenSet>,
 ];
 
 /**
@@ -384,9 +406,10 @@ export type MergeableContent<Schemas extends OptionalSchemas> = [
 export type MergeableChanges<
   Schemas extends OptionalSchemas,
   Hashed extends boolean = false,
+  WhenSet extends boolean = false,
 > = [
-  mergeableTables: TablesStamp<Schemas[0], Hashed>,
-  mergeableValues: ValuesStamp<Schemas[1], Hashed>,
+  mergeableTables: TablesStamp<Schemas[0], Hashed, WhenSet>,
+  mergeableValues: ValuesStamp<Schemas[1], Hashed, WhenSet>,
   isChanges: 1,
 ];
 
@@ -1017,7 +1040,7 @@ export interface MergeableStore<
    * @since v5.0.0
    */
   setMergeableContent(
-    mergeableContent: MergeableContent<Schemas>,
+    mergeableContent: MergeableContent<Schemas, true>,
   ): MergeableStore<Schemas>;
 
   /**
@@ -1161,7 +1184,8 @@ export interface MergeableStore<
    * @since v5.0.0
    */
   applyMergeableChanges(
-    mergeableChanges: MergeableChanges<Schemas> | MergeableContent<Schemas>,
+    mergeableChanges:
+      MergeableChanges<Schemas, false, true> | MergeableContent<Schemas, true>,
   ): MergeableStore<Schemas>;
 
   /**
@@ -1590,19 +1614,19 @@ export interface MergeableStore<
  *         {
  *           fido: [
  *             {
- *               sold: [false, 'Nn1JUF----2FnHIC', 2603026204],
+ *               sold: [false, '', 3177411910],
  *               species: ['dog', 'Nn1JUF----1FnHIC', 2817056260],
  *             },
  *             '',
- *             2859424112,
+ *             3078067457,
  *           ],
  *         },
  *         '',
- *         1640515891,
+ *         1137907280,
  *       ],
  *     },
  *     '',
- *     2077041985,
+ *     401719767,
  *   ],
  *   [{}, '', 0],
  * ];

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

@@ -205,10 +205,10 @@ export type PersistedChanges<
  * neither are present, the content will be loaded using the Persister's load
  * method. Prior to v5.0, these parameters were callbacks and the overall type
  * was non-generic.
- * @param content If provided, this is a Content object from the Persister
- * that will be used to immediately wholesale update the Store.
- * @param changes If provided, this is a Changes object from the Persister
- * that will be used to immediately incrementally update the Store. This takes
+ * @param content If provided, this is a Content object from the Persister that
+ * will be used to immediately wholesale update the Store.
+ * @param changes If provided, this is a Changes object from the Persister that
+ * will be used to immediately incrementally update the Store. This takes
  * priority over the content argument above if present.
  * @category Creation
  * @since v4.0.0
@@ -801,12 +801,15 @@ export type DpcTabularSave = {
  * Note that both loading and saving of Values from and to the database are
  * disabled by default.
  *
+ * The `load` and `save` properties can be set to `true` to persist all Values,
+ * or to a DpcTabularValuesIn array to persist just a subset of Value Ids.
+ *
  * The 'Dpc' prefix indicates that this type is used within the
  * DatabasePersisterConfig type.
  * @example
  * When applied to a database Persister, this DatabasePersisterConfig will load
- * and save the data of a Store's Values into a database
- * table called 'my_tinybase_values'.
+ * and save the data of two Store Values into a database table called
+ * 'my_tinybase_values'.
  *
  * ```js
  * import type {DatabasePersisterConfig} from 'tinybase';
@@ -814,8 +817,8 @@ export type DpcTabularSave = {
  * export const databasePersisterConfig: DatabasePersisterConfig = {
  *   mode: 'tabular',
  *   values: {
- *     load: true,
- *     save: true,
+ *     load: ['selectedPet', 'open'],
+ *     save: ['selectedPet', 'open'],
  *     tableName: 'my_tinybase_values',
  *   },
  * };
@@ -825,17 +828,19 @@ export type DpcTabularSave = {
  */
 export type DpcTabularValues = {
   /**
-   * Whether Store Values will be loaded from a database table.
+   * Whether Store Values will be loaded from a database table, or the subset of
+   * Value Ids that will be loaded.
    * @category Configuration
    * @since v4.0.0
    */
-  load?: boolean;
+  load?: boolean | DpcTabularValuesIn;
   /**
-   * Whether Store Values will be saved to a database table.
+   * Whether Store Values will be saved to a database table, or the subset of
+   * Value Ids that will be saved.
    * @category Configuration
    * @since v4.0.0
    */
-  save?: boolean;
+  save?: boolean | DpcTabularValuesIn;
   /**
    * The optional name of the database table from and to which the Store Values
    * should be loaded or saved, defaulting to `tinybase_values`.
@@ -845,6 +850,21 @@ export type DpcTabularValues = {
   tableName?: string;
 };
 
+/**
+ * The DpcTabularValuesIn type describes the subset of Store Values that are
+ * persisted by the DpcTabularValues type.
+ *
+ * When used as the DpcTabularValues `load` or `save` property, only the listed
+ * Value Ids will be loaded from or saved to the database table. Unlisted
+ * database columns are ignored on load and left untouched on save.
+ *
+ * The 'Dpc' prefix indicates that this type is used within the
+ * DatabasePersisterConfig type.
+ * @category Configuration
+ * @since v9.0.0
+ */
+export type DpcTabularValuesIn = Id[];
+
 /**
  * A Persister object lets you save and load Store data to and from different
  * locations, or underlying storage types.
@@ -1740,7 +1760,8 @@ export type DatabaseChangeListener = (tableName: string) => void;
  * `stopListeningToPersisted` has been renamed `delPersisterListener`.
  * @param store The Store to persist.
  * @param getPersisted An asynchronous function which will fetch content from
- * the persistence layer (or `undefined` if not present).
+ * the persistence layer. If it returns `undefined`, the load will use the
+ * provided initial content if present, and otherwise leave the Store unchanged.
  * @param setPersisted An asynchronous function which will send content to the
  * persistence layer. Since v4.0, it receives functions for getting the Store
  * content and information about the changes made during a transaction. Since

package/@types/persisters/persister-durable-object-sql-storage/index.d.ts

@@ -30,10 +30,10 @@ import type {DpcJson, Persister, Persists} from '../index.d.ts';
  * The DpcFragmented type represents the configuration for fragmented
  * persistence mode in a DurableObjectSqlStoragePersister.
  *
- * This mode stores each table, row, cell, and value as separate database rows,
- * avoiding Cloudflare's 2MB row limit that can be hit with large stores in JSON
- * mode. While this creates more database writes, it provides better scalability
- * for larger datasets.
+ * This mode stores each table's metadata, row data, and values as separate
+ * database rows, avoiding Cloudflare's 2MB row limit that can be hit with
+ * large stores in JSON mode. While this creates more database writes than JSON
+ * mode, it provides better scalability for larger datasets.
  * @example
  * This example shows how to configure a DurableObjectSqlStoragePersister to use
  * fragmented mode with a custom storage prefix.
@@ -220,10 +220,11 @@ export interface DurableObjectSqlStoragePersister extends Persister<Persists.Mer
  *   database row. This is efficient for smaller stores but may hit Cloudflare's
  *   2MB row limit for very large stores and uses fewer database writes.
  *
- * - **Fragmented Mode**: Stores each table, row, cell, and value as separate
- *   database rows. Use this mode if you're concerned about hitting Cloudflare's
- *   2MB row limit with large stores in JSON mode. This mode creates more
- *   database writes but avoids row size limitations.
+ * - **Fragmented Mode**: Stores each table's metadata, row data, and values as
+ *   separate database rows. Use this mode if you're concerned about hitting
+ *   Cloudflare's 2MB row limit with large stores in JSON mode. This mode
+ *   creates more database writes than JSON mode but avoids row size
+ *   limitations.
  *
  * 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

package/@types/persisters/persister-durable-object-sql-storage/with-schemas/index.d.ts

@@ -38,10 +38,10 @@ import type {
  * The DpcFragmented type represents the configuration for fragmented
  * persistence mode in a DurableObjectSqlStoragePersister.
  *
- * This mode stores each table, row, cell, and value as separate database rows,
- * avoiding Cloudflare's 2MB row limit that can be hit with large stores in JSON
- * mode. While this creates more database writes, it provides better scalability
- * for larger datasets.
+ * This mode stores each table's metadata, row data, and values as separate
+ * database rows, avoiding Cloudflare's 2MB row limit that can be hit with
+ * large stores in JSON mode. While this creates more database writes than JSON
+ * mode, it provides better scalability for larger datasets.
  * @example
  * This example shows how to configure a DurableObjectSqlStoragePersister to use
  * fragmented mode with a custom storage prefix.
@@ -250,10 +250,11 @@ export interface DurableObjectSqlStoragePersister<
  *   database row. This is efficient for smaller stores but may hit Cloudflare's
  *   2MB row limit for very large stores and uses fewer database writes.
  *
- * - **Fragmented Mode**: Stores each table, row, cell, and value as separate
- *   database rows. Use this mode if you're concerned about hitting Cloudflare's
- *   2MB row limit with large stores in JSON mode. This mode creates more
- *   database writes but avoids row size limitations.
+ * - **Fragmented Mode**: Stores each table's metadata, row data, and values as
+ *   separate database rows. Use this mode if you're concerned about hitting
+ *   Cloudflare's 2MB row limit with large stores in JSON mode. This mode
+ *   creates more database writes than JSON mode but avoids row size
+ *   limitations.
  *
  * 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
@@ -379,8 +380,7 @@ export function createDurableObjectSqlStoragePersister<
   store: Store<Schemas> | MergeableStore<Schemas>,
   sqlStorage: SqlStorage,
   configOrStoreTableName?:
-    | DurableObjectSqlDatabasePersisterConfig<Schemas>
-    | string,
+    DurableObjectSqlDatabasePersisterConfig<Schemas> | string,
   onSqlCommand?: (sql: string, params?: any[]) => void,
   onIgnoredError?: (error: any) => void,
 ): DurableObjectSqlStoragePersister<Schemas>;

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

@@ -55,7 +55,10 @@
  * @module persisters
  * @since v1.0.0
  */
-import type {TableIdFromSchema} from '../../_internal/store/with-schemas/index.d.ts';
+import type {
+  TableIdFromSchema,
+  ValueIdFromSchema,
+} from '../../_internal/store/with-schemas/index.d.ts';
 import type {
   MergeableChanges,
   MergeableContent,
@@ -66,6 +69,7 @@ import type {
   Content,
   OptionalSchemas,
   OptionalTablesSchema,
+  OptionalValuesSchema,
   Store,
 } from '../../store/with-schemas/index.d.ts';
 import type {Id} from '../../with-schemas/index.d.ts';
@@ -198,11 +202,12 @@ export type PersistedStore<
 export type PersistedContent<
   Schemas extends OptionalSchemas,
   Persist extends Persists = Persists.StoreOnly,
+  WhenSet extends boolean = false,
 > = Persist extends Persists.StoreOrMergeableStore
-  ? Content<Schemas> | MergeableContent<Schemas>
+  ? Content<Schemas, WhenSet> | MergeableContent<Schemas, WhenSet>
   : Persist extends Persists.MergeableStoreOnly
-    ? MergeableContent<Schemas>
-    : Content<Schemas>;
+    ? MergeableContent<Schemas, WhenSet>
+    : Content<Schemas, WhenSet>;
 
 /**
  * The PersistedChanges type is a generic representation of changes made to the
@@ -231,10 +236,11 @@ export type PersistedContent<
 export type PersistedChanges<
   Schemas extends OptionalSchemas,
   Persist extends Persists = Persists.StoreOnly,
+  WhenSet extends boolean = false,
 > = Persist extends Persists.StoreOrMergeableStore
-  ? Changes<Schemas> | MergeableChanges<Schemas>
+  ? Changes<Schemas> | MergeableChanges<Schemas, false, WhenSet>
   : Persist extends Persists.MergeableStoreOnly
-    ? MergeableChanges<Schemas>
+    ? MergeableChanges<Schemas, false, WhenSet>
     : Changes<Schemas>;
 
 /**
@@ -260,10 +266,10 @@ export type PersistedChanges<
  * neither are present, the content will be loaded using the Persister's load
  * method. Prior to v5.0, these parameters were callbacks and the overall type
  * was non-generic.
- * @param content If provided, this is a Content object from the Persister
- * that will be used to immediately wholesale update the Store.
- * @param changes If provided, this is a Changes object from the Persister
- * that will be used to immediately incrementally update the Store. This takes
+ * @param content If provided, this is a Content object from the Persister that
+ * will be used to immediately wholesale update the Store.
+ * @param changes If provided, this is a Changes object from the Persister that
+ * will be used to immediately incrementally update the Store. This takes
  * priority over the content argument above if present.
  * @category Creation
  * @since v4.0.0
@@ -271,9 +277,10 @@ export type PersistedChanges<
 export type PersisterListener<
   Schemas extends OptionalSchemas,
   Persist extends Persists = Persists.StoreOnly,
+  WhenSet extends boolean = false,
 > = (
-  content?: PersistedContent<Schemas, Persist>,
-  changes?: PersistedChanges<Schemas, Persist>,
+  content?: PersistedContent<Schemas, Persist, WhenSet>,
+  changes?: PersistedChanges<Schemas, Persist, WhenSet>,
 ) => void;
 
 /**
@@ -394,8 +401,7 @@ export type PersisterStats = {
  * @since v4.0.0
  */
 export type DatabasePersisterConfig<Schemas extends OptionalSchemas> =
-  | DpcJson
-  | DpcTabular<Schemas[0]>;
+  DpcJson | DpcTabular<Schemas[0], Schemas[1]>;
 
 /**
  * The DpcJson type describes the configuration of a database-oriented Persister
@@ -552,7 +558,10 @@ export type DpcJson = {
  * @category Configuration
  * @since v4.0.0
  */
-export type DpcTabular<Schema extends OptionalTablesSchema> = {
+export type DpcTabular<
+  TablesSchema extends OptionalTablesSchema,
+  ValuesSchema extends OptionalValuesSchema = OptionalValuesSchema,
+> = {
   /**
    * The mode to be used for persisting the Store to the database, in this case
    * tabular mapping. See the DpcJson type for the alternative JSON
@@ -573,21 +582,21 @@ export type DpcTabular<Schema extends OptionalTablesSchema> = {
      * @category Configuration
      * @since v4.0.0
      */
-    load?: DpcTabularLoad<Schema>;
+    load?: DpcTabularLoad<TablesSchema>;
     /**
      * The settings for how the Store Tables are mapped out to the database
      * tables when saving.
      * @category Configuration
      * @since v4.0.0
      */
-    save?: DpcTabularSave<Schema>;
+    save?: DpcTabularSave<TablesSchema>;
   };
   /**
    * The settings for how the Store Values are mapped to and from the database.
    * @category Configuration
    * @since v4.0.0
    */
-  values?: DpcTabularValues;
+  values?: DpcTabularValues<ValuesSchema>;
   /**
    * How often the Persister should poll the database for any changes made to it
    * by other clients, defaulting to 1 second.
@@ -876,12 +885,15 @@ export type DpcTabularSave<Schema extends OptionalTablesSchema> = {
  * Note that both loading and saving of Values from and to the database are
  * disabled by default.
  *
+ * The `load` and `save` properties can be set to `true` to persist all Values,
+ * or to a DpcTabularValuesIn array to persist just a subset of Value Ids.
+ *
  * The 'Dpc' prefix indicates that this type is used within the
  * DatabasePersisterConfig type.
  * @example
  * When applied to a database Persister, this DatabasePersisterConfig will load
- * and save the data of a Store's Values into a database
- * table called 'my_tinybase_values'.
+ * and save the data of two Store Values into a database table called
+ * 'my_tinybase_values'.
  *
  * ```js
  * import type {DatabasePersisterConfig} from 'tinybase';
@@ -889,8 +901,8 @@ export type DpcTabularSave<Schema extends OptionalTablesSchema> = {
  * export const databasePersisterConfig: DatabasePersisterConfig = {
  *   mode: 'tabular',
  *   values: {
- *     load: true,
- *     save: true,
+ *     load: ['selectedPet', 'open'],
+ *     save: ['selectedPet', 'open'],
  *     tableName: 'my_tinybase_values',
  *   },
  * };
@@ -898,19 +910,23 @@ export type DpcTabularSave<Schema extends OptionalTablesSchema> = {
  * @category Configuration
  * @since v4.0.0
  */
-export type DpcTabularValues = {
+export type DpcTabularValues<
+  Schema extends OptionalValuesSchema = OptionalValuesSchema,
+> = {
   /**
-   * Whether Store Values will be loaded from a database table.
+   * Whether Store Values will be loaded from a database table, or the subset of
+   * Value Ids that will be loaded.
    * @category Configuration
    * @since v4.0.0
    */
-  load?: boolean;
+  load?: boolean | DpcTabularValuesIn<Schema>;
   /**
-   * Whether Store Values will be saved to a database table.
+   * Whether Store Values will be saved to a database table, or the subset of
+   * Value Ids that will be saved.
    * @category Configuration
    * @since v4.0.0
    */
-  save?: boolean;
+  save?: boolean | DpcTabularValuesIn<Schema>;
   /**
    * The optional name of the database table from and to which the Store Values
    * should be loaded or saved, defaulting to `tinybase_values`.
@@ -920,6 +936,29 @@ export type DpcTabularValues = {
   tableName?: string;
 };
 
+/**
+ * The DpcTabularValuesIn type describes the subset of Store Values that are
+ * persisted by the DpcTabularValues type.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * Id[];
+ * ```
+ *
+ * When used as the DpcTabularValues `load` or `save` property, only the listed
+ * Value Ids will be loaded from or saved to the database table. Unlisted
+ * database columns are ignored on load and left untouched on save.
+ *
+ * The 'Dpc' prefix indicates that this type is used within the
+ * DatabasePersisterConfig type.
+ * @category Configuration
+ * @since v9.0.0
+ */
+export type DpcTabularValuesIn<
+  Schema extends OptionalValuesSchema = OptionalValuesSchema,
+> = ValueIdFromSchema<Schema>[];
+
 /**
  * A Persister object lets you save and load Store data to and from different
  * locations, or underlying storage types.
@@ -1880,7 +1919,8 @@ export type DatabaseChangeListener = (tableName: string) => void;
  * `stopListeningToPersisted` has been renamed `delPersisterListener`.
  * @param store The Store to persist.
  * @param getPersisted An asynchronous function which will fetch content from
- * the persistence layer (or `undefined` if not present).
+ * the persistence layer. If it returns `undefined`, the load will use the
+ * provided initial content if present, and otherwise leave the Store unchanged.
  * @param setPersisted An asynchronous function which will send content to the
  * persistence layer. Since v4.0, it receives functions for getting the Store
  * content and information about the changes made during a transaction. Since
@@ -2016,13 +2056,15 @@ export function createCustomPersister<
   Persist extends Persists = Persists.StoreOnly,
 >(
   store: PersistedStore<Schemas, Persist>,
-  getPersisted: () => Promise<PersistedContent<Schemas, Persist> | undefined>,
+  getPersisted: () => Promise<
+    PersistedContent<Schemas, Persist, true> | undefined
+  >,
   setPersisted: (
     getContent: () => PersistedContent<Schemas, Persist>,
     changes?: PersistedChanges<Schemas, Persist>,
   ) => Promise<void>,
   addPersisterListener: (
-    listener: PersisterListener<Schemas, Persist>,
+    listener: PersisterListener<Schemas, Persist, true>,
   ) => ListenerHandle | Promise<ListenerHandle>,
   delPersisterListener: (
     listenerHandle: ListenerHandle,

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

@@ -42,13 +42,7 @@ import type {
  * @since v7.2.0
  */
 export type ParamValue =
-  | string
-  | number
-  | boolean
-  | null
-  | string[]
-  | number[]
-  | boolean[];
+  string | number | boolean | null | string[] | number[] | boolean[];
 
 /**
  * The ParamValues type describes an object of param values, keyed by param Id,
@@ -861,6 +855,10 @@ export type Param = (paramId: Id) => ParamValue | undefined;
  * The Select function is provided to the third `query` parameter of the
  * setQueryDefinition method. A query definition must call the Select function
  * at least once, otherwise it will be meaningless and return no data.
+ *
+ * A Row will only appear in the ResultTable if at least one Select clause
+ * produces a defined value for it. If all selected Cells or calculated values
+ * resolve to `undefined`, no ResultRow is created for that Row.
  * @example
  * This example shows a query that selects two Cells from the main query Table.
  *