tinybase 9.5.0-beta.0 → 9.5.0-beta.1

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

@@ -231,6 +231,18 @@ export type TableInHtmlTableProps<
               [CellId in CellIdFromSchema<Schemas[0], TableId>]?:
                 string | CustomCell<Schemas, TableId, CellId>;
             };
+        /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+        readonly extraCellsBefore?: ExtraRowCell<Schemas, TableId>[];
+        /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+        readonly extraCellsAfter?: ExtraRowCell<Schemas, TableId>[];
       }
     : never
   : never;
@@ -311,6 +323,18 @@ export type SortedTableInHtmlTableProps<
                 string | CustomCell<Schemas, TableId, CellId>;
             };
         /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+        readonly extraCellsBefore?: ExtraRowCell<Schemas, TableId>[];
+        /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+        readonly extraCellsAfter?: ExtraRowCell<Schemas, TableId>[];
+        /**
    * Whether the table should be interactive such that clicking a header changes
    * the sorting and/or direction.
    * @category Prop
@@ -378,6 +402,18 @@ export type ValuesInHtmlTableProps<Schemas extends OptionalSchemas> = {
    * @since v4.1.0
    */
   readonly getValueComponentProps?: (valueId: Id) => ExtraProps;
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsBefore?: ExtraValueCell<Schemas>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsAfter?: ExtraValueCell<Schemas>[];
 };
 
 /**
@@ -426,6 +462,18 @@ export type SliceInHtmlTableProps<Schemas extends OptionalSchemas> = {
    */
   readonly customCells?:
     Ids | {[cellId: Id]: string | CustomCell<NoSchemas, Id, Id>};
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
 };
 
 /**
@@ -476,6 +524,18 @@ export type RelationshipInHtmlTableProps<Schemas extends OptionalSchemas> = {
    */
   readonly customCells?:
     Ids | {[cellId: Id]: string | CustomCell<NoSchemas, Id, Id>};
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
 };
 
 /**
@@ -511,6 +571,18 @@ export type ResultTableInHtmlTableProps<Schemas extends OptionalSchemas> = {
    */
   readonly customCells?:
     Ids | {[cellId: Id]: string | CustomResultCell<Schemas>};
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+  readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
 };
 
 /**
@@ -574,6 +646,18 @@ export type ResultSortedTableInHtmlTableProps<Schemas extends OptionalSchemas> =
     readonly customCells?:
       Ids | {[cellId: Id]: string | CustomResultCell<Schemas>};
     /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+    readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+    /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v6.6.0
+   */
+    readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
+    /**
    * Whether the table should be interactive such that clicking a header changes
    * the sorting and/or direction.
    * @category Prop

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

@@ -7098,7 +7098,52 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     metricsOrMetricsId?: MaybeAccessor<MetricsOrMetricsId<Schemas> | undefined>,
   ) => Accessor<Metrics<Schemas> | undefined>;
 
-  // useProvideMetrics
+  /**
+ * The useProvideMetrics primitive is used to add a Metrics object by Id to a
+ * Provider component, but imperatively from a component within it.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useProvideMetrics(metricsId: Id, metrics: Metrics): void;
+ * ```
+ *
+ * Normally you will register a Metrics object by Id in a context by using the
+ * `metricsById` prop of the top-level Provider component. This primitive,
+ * however, lets you dynamically add a new Metrics object to the context, from
+ * within a descendent component. This is useful for applications where the set
+ * of Metrics objects is not known at the time of the first render of the root
+ * Provider.
+ *
+ * A Metrics object added to the Provider context in this way will be available
+ * to other components within the context (using the useMetrics primitive and so
+ * on). If you use the same Id as an existing Metrics object registration, the
+ * new one will take priority over one provided by the `metricsById` prop.
+ * @param metricsId The Id of the Metrics object to be registered with the
+ * Provider.
+ * @param metrics The Metrics object to be registered.
+ * @example
+ * ```js
+ * import {createRoot} from 'solid-js';
+ * import {createMetrics, createStore} from 'tinybase';
+ * import {useProvideMetrics} from 'tinybase/ui-solid';
+ *
+ * createRoot((dispose) => {
+ *   const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ *   const metrics = createMetrics(store).setMetricDefinition(
+ *     'petCount',
+ *     'pets',
+ *     'count',
+ *   );
+ *   useProvideMetrics('petMetrics', metrics);
+ *   console.log(metrics.getMetric('petCount'));
+ *   // -> 1
+ *   dispose();
+ * });
+ * ```
+ * @category Metrics primitives
+ * @since v8.3.0
+ */
   useProvideMetrics: (metricsId: Id, metrics: Metrics<Schemas>) => void;
 
   /**
@@ -7741,7 +7786,52 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
   ) => Accessor<Indexes<Schemas> | undefined>;
 
-  // useProvideIndexes
+  /**
+ * The useProvideIndexes primitive is used to add an Indexes object by Id to a
+ * Provider component, but imperatively from a component within it.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useProvideIndexes(indexesId: Id, indexes: Indexes): void;
+ * ```
+ *
+ * Normally you will register an Indexes object by Id in a context by using the
+ * `indexesById` prop of the top-level Provider component. This primitive,
+ * however, lets you dynamically add a new Indexes object to the context, from
+ * within a descendent component. This is useful for applications where the set
+ * of Indexes objects is not known at the time of the first render of the root
+ * Provider.
+ *
+ * An Indexes object added to the Provider context in this way will be available
+ * to other components within the context (using the useIndexes primitive and so
+ * on). If you use the same Id as an existing Indexes object registration, the
+ * new one will take priority over one provided by the `indexesById` prop.
+ * @param indexesId The Id of the Indexes object to be registered with the
+ * Provider.
+ * @param indexes The Indexes object to be registered.
+ * @example
+ * ```js
+ * import {createRoot} from 'solid-js';
+ * import {createIndexes, createStore} from 'tinybase';
+ * import {useProvideIndexes} from 'tinybase/ui-solid';
+ *
+ * createRoot((dispose) => {
+ *   const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ *   const indexes = createIndexes(store).setIndexDefinition(
+ *     'petsByColor',
+ *     'pets',
+ *     'color',
+ *   );
+ *   useProvideIndexes('petIndexes', indexes);
+ *   console.log(JSON.stringify(indexes.getSliceIds('petsByColor')));
+ *   // -> '["brown"]'
+ *   dispose();
+ * });
+ * ```
+ * @category Indexes primitives
+ * @since v8.3.0
+ */
   useProvideIndexes: (indexesId: Id, indexes: Indexes<Schemas>) => void;
 
   /**
@@ -8662,7 +8752,56 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     >,
   ) => Accessor<Relationships<Schemas> | undefined>;
 
-  // useProvideRelationships
+  /**
+ * The useProvideRelationships primitive is used to add a Relationships object
+ * by Id to a Provider component, but imperatively from a component within it.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useProvideRelationships(
+ *   relationshipsId: Id,
+ *   relationships: Relationships,
+ * ): void;
+ * ```
+ *
+ * Normally you will register a Relationships object by Id in a context by using
+ * the `relationshipsById` prop of the top-level Provider component. This
+ * primitive, however, lets you dynamically add a new Relationships object to
+ * the context, from within a component. This is useful for applications where
+ * the set of Relationships objects is not known at the time of the first render
+ * of the root Provider.
+ *
+ * A Relationships object added to the Provider context in this way will be
+ * available to other components within the context (using the useRelationships
+ * primitive and so on). If you use the same Id as an existing Relationships
+ * object registration, the new one will take priority over one provided by the
+ * `relationshipsById` prop.
+ * @param relationshipsId The Id of the Relationships object to be registered
+ * with the Provider.
+ * @param relationships The Relationships object to be registered.
+ * @example
+ * ```js
+ * import {createRoot} from 'solid-js';
+ * import {createRelationships, createStore} from 'tinybase';
+ * import {useProvideRelationships} from 'tinybase/ui-solid';
+ *
+ * createRoot((dispose) => {
+ *   const store = createStore()
+ *     .setTable('pets', {fido: {species: 'dog'}})
+ *     .setTable('species', {dog: {price: 5}});
+ *   const relationships = createRelationships(
+ *     store,
+ *   ).setRelationshipDefinition('petSpecies', 'pets', 'species', 'species');
+ *   useProvideRelationships('petRelationships', relationships);
+ *   console.log(relationships.getRemoteRowId('petSpecies', 'fido'));
+ *   // -> 'dog'
+ *   dispose();
+ * });
+ * ```
+ * @category Relationships primitives
+ * @since v8.3.0
+ */
   useProvideRelationships: (
     relationshipsId: Id,
     relationships: Relationships<Schemas>,
@@ -9790,7 +9929,57 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     queriesOrQueriesId?: MaybeAccessor<QueriesOrQueriesId<Schemas> | undefined>,
   ) => Accessor<Queries<Schemas> | undefined>;
 
-  // useProvideQueries
+  /**
+ * The useProvideQueries primitive is used to add a Queries object by Id to a
+ * Provider component, but imperatively from a component within it.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useProvideQueries(queriesId: Id, queries: Queries): void;
+ * ```
+ *
+ * Normally you will register a Queries object by Id in a context by using the
+ * `queriesById` prop of the top-level Provider component. This primitive,
+ * however, lets you dynamically add a new Queries object to the context, from
+ * within a component. This is useful for applications where the set of Queries
+ * objects is not known at the time of the first render of the root Provider.
+ *
+ * A Queries object added to the Provider context in this way will be available
+ * to other components within the context (using the useQueries primitive and so
+ * on). If you use the same Id as an existing Queries object registration, the
+ * new one will take priority over one provided by the `queriesById` prop.
+ * @param queriesId The Id of the Queries object to be registered with the
+ * Provider.
+ * @param queries The Queries object to be registered.
+ * @example
+ * ```js
+ * import {createRoot} from 'solid-js';
+ * import {createQueries, createStore} from 'tinybase';
+ * import {useProvideQueries} from 'tinybase/ui-solid';
+ *
+ * createRoot((dispose) => {
+ *   const store = createStore().setRow('pets', 'fido', {
+ *     color: 'brown',
+ *     legs: 4,
+ *   });
+ *   const queries = createQueries(store).setQueryDefinition(
+ *     'brownLegs',
+ *     'pets',
+ *     ({select, where}) => {
+ *       select('legs');
+ *       where('color', 'brown');
+ *     },
+ *   );
+ *   useProvideQueries('petQueries', queries);
+ *   console.log(JSON.stringify(queries.getResultTable('brownLegs')));
+ *   // -> '{"fido":{"legs":4}}'
+ *   dispose();
+ * });
+ * ```
+ * @category Queries primitives
+ * @since v8.3.0
+ */
   useProvideQueries: (queriesId: Id, queries: Queries<Schemas>) => void;
 
   /**
@@ -12744,7 +12933,52 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     >,
   ) => Accessor<Checkpoints<Schemas> | undefined>;
 
-  // useProvideCheckpoints
+  /**
+ * The useProvideCheckpoints primitive is used to add a Checkpoints object by Id
+ * to a Provider component, but imperatively from a component within it.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useProvideCheckpoints(
+ *   checkpointsId: Id,
+ *   checkpoints: Checkpoints,
+ * ): void;
+ * ```
+ *
+ * Normally you will register a Checkpoints object by Id in a context by using
+ * the `checkpointsById` prop of the top-level Provider component. This
+ * primitive, however, lets you dynamically add a new Checkpoints object to the
+ * context, from within a component. This is useful for applications where the
+ * set of Checkpoints objects is not known at the time of the first render of
+ * the root Provider.
+ *
+ * A Checkpoints object added to the Provider context in this way will be
+ * available to other components within the context (using the useCheckpoints
+ * primitive and so on). If you use the same Id as an existing Checkpoints
+ * object registration, the new one will take priority over one provided by the
+ * `checkpointsById` prop.
+ * @param checkpointsId The Id of the Checkpoints object to be registered with
+ * the Provider.
+ * @param checkpoints The Checkpoints object to be registered.
+ * @example
+ * ```js
+ * import {createRoot} from 'solid-js';
+ * import {createCheckpoints, createStore} from 'tinybase';
+ * import {useProvideCheckpoints} from 'tinybase/ui-solid';
+ *
+ * createRoot((dispose) => {
+ *   const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ *   const checkpoints = createCheckpoints(store);
+ *   useProvideCheckpoints('petCheckpoints', checkpoints);
+ *   console.log(JSON.stringify(checkpoints.getCheckpointIds()));
+ *   // -> '[[],"0",[]]'
+ *   dispose();
+ * });
+ * ```
+ * @category Checkpoints primitives
+ * @since v8.3.0
+ */
   useProvideCheckpoints: (
     checkpointsId: Id,
     checkpoints: Checkpoints<Schemas>,
@@ -14110,7 +14344,54 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     >,
   ) => Accessor<Persister<Schemas, Persists.StoreOrMergeableStore> | undefined>;
 
-  // useProvidePersister
+  /**
+ * The useProvidePersister primitive is used to add a Persister object by Id to
+ * a Provider component, but imperatively from a component within it.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useProvidePersister(
+ *   persisterId: Id,
+ *   persister: AnyPersister,
+ * ): void;
+ * ```
+ *
+ * Normally you will register a Persister object by Id in a context by using the
+ * `persistersById` prop of the top-level Provider component. This primitive,
+ * however, lets you dynamically add a new Persister object to the context, from
+ * within a component. This is useful for applications where the set of
+ * Persister objects is not known at the time of the first render of the root
+ * Provider.
+ *
+ * A Persister object added to the Provider context in this way will be
+ * available to other components within the context (using the usePersister
+ * primitive and so on). If you use the same Id as an existing Persister object
+ * registration, the new one will take priority over one provided by the
+ * `persistersById` prop.
+ * @param persisterId The Id of the Persister object to be registered with the
+ * Provider.
+ * @param persister The Persister object to be registered.
+ * @example
+ * ```js
+ * import {createRoot} from 'solid-js';
+ * import {createStore} from 'tinybase';
+ * import {createSessionPersister} from 'tinybase/persisters/persister-browser';
+ * import {useProvidePersister} from 'tinybase/ui-solid';
+ *
+ * createRoot((dispose) => {
+ *   const store = createStore().setCell('pets', 'fido', 'color', 'brown');
+ *   const persister = createSessionPersister(store, 'pets');
+ *   useProvidePersister('petPersister', persister);
+ *   console.log(persister.getStatus());
+ *   // -> 0
+ *   persister.destroy();
+ *   dispose();
+ * });
+ * ```
+ * @category Persister primitives
+ * @since v8.3.0
+ */
   useProvidePersister: (
     persisterId: Id,
     persister: AnyPersister<Schemas> | undefined,
@@ -14681,7 +14962,59 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     >,
   ) => Accessor<Synchronizer<Schemas> | undefined>;
 
-  // useProvideSynchronizer
+  /**
+ * The useProvideSynchronizer primitive is used to add a Synchronizer object by
+ * Id to a Provider component, but imperatively from a component within it.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useProvideSynchronizer(
+ *   synchronizerId: Id,
+ *   synchronizer: Synchronizer,
+ * ): void;
+ * ```
+ *
+ * Normally you will register a Synchronizer object by Id in a context by using
+ * the `synchronizersById` prop of the top-level Provider component. This
+ * primitive, however, lets you dynamically add a new Synchronizer object to the
+ * context, from within a component. This is useful for applications where the
+ * set of Synchronizer objects is not known at the time of the first render of
+ * the root Provider.
+ *
+ * A Synchronizer object added to the Provider context in this way will be
+ * available to other components within the context (using the useSynchronizer
+ * primitive and so on). If you use the same Id as an existing Synchronizer
+ * object registration, the new one will take priority over one provided by the
+ * `synchronizersById` prop.
+ * @param synchronizerId The Id of the Synchronizer object to be registered with
+ * the Provider.
+ * @param synchronizer The Synchronizer object to be registered.
+ * @example
+ * ```js
+ * import {createRoot} from 'solid-js';
+ * import {createMergeableStore} from 'tinybase';
+ * import {createLocalSynchronizer} from 'tinybase/synchronizers/synchronizer-local';
+ * import {useProvideSynchronizer} from 'tinybase/ui-solid';
+ *
+ * createRoot((dispose) => {
+ *   const store = createMergeableStore().setCell(
+ *     'pets',
+ *     'fido',
+ *     'color',
+ *     'brown',
+ *   );
+ *   const synchronizer = createLocalSynchronizer(store);
+ *   useProvideSynchronizer('petSynchronizer', synchronizer);
+ *   console.log(synchronizer.getStatus());
+ *   // -> 0
+ *   synchronizer.destroy();
+ *   dispose();
+ * });
+ * ```
+ * @category Synchronizer primitives
+ * @since v8.3.0
+ */
   useProvideSynchronizer: (
     synchronizerId: Id,
     synchronizer: Synchronizer<Schemas> | undefined,

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

@@ -232,6 +232,18 @@ export type TableInHtmlTableProps<
               [CellId in CellIdFromSchema<Schemas[0], TableId>]?:
                 string | CustomCell<Schemas, TableId, CellId>;
             };
+        /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+        readonly extraCellsBefore?: ExtraRowCell<Schemas, TableId>[];
+        /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+        readonly extraCellsAfter?: ExtraRowCell<Schemas, TableId>[];
       }
     : never
   : never;
@@ -312,6 +324,18 @@ export type SortedTableInHtmlTableProps<
                 string | CustomCell<Schemas, TableId, CellId>;
             };
         /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+        readonly extraCellsBefore?: ExtraRowCell<Schemas, TableId>[];
+        /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+        readonly extraCellsAfter?: ExtraRowCell<Schemas, TableId>[];
+        /**
    * Whether the table should be interactive such that clicking a header changes
    * the sorting and/or direction.
    * @category Prop
@@ -379,6 +403,18 @@ export type ValuesInHtmlTableProps<Schemas extends OptionalSchemas> = {
    * @since v8.4.0
    */
   readonly getValueComponentProps?: (valueId: Id) => ExtraProps;
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsBefore?: ExtraValueCell<Schemas>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsAfter?: ExtraValueCell<Schemas>[];
 };
 
 /**
@@ -427,6 +463,18 @@ export type SliceInHtmlTableProps<Schemas extends OptionalSchemas> = {
    */
   readonly customCells?:
     Ids | {[cellId: Id]: string | CustomCell<NoSchemas, Id, Id>};
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
 };
 
 /**
@@ -477,6 +525,18 @@ export type RelationshipInHtmlTableProps<Schemas extends OptionalSchemas> = {
    */
   readonly customCells?:
     Ids | {[cellId: Id]: string | CustomCell<NoSchemas, Id, Id>};
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
 };
 
 /**
@@ -512,6 +572,18 @@ export type ResultTableInHtmlTableProps<Schemas extends OptionalSchemas> = {
    */
   readonly customCells?:
     Ids | {[cellId: Id]: string | CustomResultCell<Schemas>};
+  /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+  /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+  readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
 };
 
 /**
@@ -575,6 +647,18 @@ export type ResultSortedTableInHtmlTableProps<Schemas extends OptionalSchemas> =
     readonly customCells?:
       Ids | {[cellId: Id]: string | CustomResultCell<Schemas>};
     /**
+   * An optional list of extra Cells to render before the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+    readonly extraCellsBefore?: ExtraRowCell<NoSchemas, Id>[];
+    /**
+   * An optional list of extra Cells to render after the main table Cells.
+   * @category Prop
+   * @since v8.4.0
+   */
+    readonly extraCellsAfter?: ExtraRowCell<NoSchemas, Id>[];
+    /**
    * Whether the table should be interactive such that clicking a header changes
    * the sorting and/or direction.
    * @category Prop

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

@@ -1,3 +1,33 @@
+/**
+ * The ui-svelte module of the TinyBase project provides reactive functions,
+ * listener functions, and components to make it easy to create reactive Svelte
+ * 5 apps with Store objects.
+ *
+ * The reactive functions in this module provide access to the data and
+ * structures exposed by other modules in the project. They return reactive
+ * objects with a `current` property. Those functions register listeners such
+ * that components using them re-render when data changes.
+ *
+ * The components in this module provide a further abstraction over those
+ * reactive functions, and use Svelte snippet props to customize rendering in an
+ * idiomatic way.
+ *
+ * Functions like the getStore function and getMetrics function return TinyBase
+ * objects directly from Provider context. Functions like the getCell function,
+ * the getRow function, the getTable function, the getValue function, and the
+ * hasCell function return reactive objects whose `current` property reflects
+ * underlying TinyBase data.
+ *
+ * Function parameters accept either plain values or reactive getter functions
+ * (as per the MaybeGetter type), so passing `() => tableId` from a `let`-bound
+ * Svelte prop makes the function re-execute whenever the prop changes.
+ * @see Building UIs With Svelte guide
+ * @see Hello World (Svelte) demo
+ * @see Countries (Svelte) demo
+ * @packageDocumentation
+ * @module ui-svelte
+ * @since v8.1.0
+ */
 import type {Component, Snippet} from 'svelte';
 import type {
   AllCellIdFromSchema,