tinybase 9.1.0-beta.0 → 9.1.0-beta.2

package/@types/ui-react/index.d.ts

@@ -36,6 +36,7 @@ import type {
   IdOrNull,
   Ids,
   ParameterizedCallback,
+  Sorter,
 } from '../common/index.d.ts';
 import type {
   Indexes,
@@ -1797,6 +1798,7 @@ export function useSortedRowIds(
   descending?: boolean,
   offset?: number,
   limit?: number,
+  sorterOrStoreOrStoreId?: Sorter | StoreOrStoreId,
   storeOrStoreId?: StoreOrStoreId,
 ): Ids;
 
@@ -1804,7 +1806,8 @@ export function useSortedRowIds(
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param storeOrStoreId The Store to be accessed: omit for the default context
  * Store, provide an Id for a named context Store, or provide an explicit
  * reference.
@@ -5178,7 +5181,8 @@ export function useSortedRowIdsListener(
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param listener The function that will be called whenever the sorted Row Ids
  * in the Table change.
  * @param listenerDeps An optional array of dependencies for the `listener`
@@ -7251,6 +7255,26 @@ export function useProvideIndexes(indexesId: Id, indexes: Indexes): void;
  */
 export function useIndexIds(indexesOrIndexesId?: IndexesOrIndexesId): Ids;
 
+/**
+ * The useHasIndex hook returns a boolean indicating whether a given Index
+ * exists in the Indexes object, and registers a listener so that any changes to
+ * that result will cause a re-render.
+ *
+ * This hook follows the same Indexes object resolution rules as the useIndexIds
+ * hook.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether an Index with that Id exists.
+ * @category Indexes hooks
+ * @since v9.1.0
+ */
+export function useHasIndex(
+  indexId: Id,
+  indexesOrIndexesId?: IndexesOrIndexesId,
+): boolean;
+
 /**
  * The useSliceIds hook gets the list of Slice Ids in an Index, and registers a
  * listener so that any changes to that result will cause a re-render.
@@ -7371,6 +7395,28 @@ export function useSliceIds(
   indexesOrIndexesId?: IndexesOrIndexesId,
 ): Ids;
 
+/**
+ * The useHasSlice hook returns a boolean indicating whether a given Slice
+ * exists in an Index, and registers a listener so that any changes to that
+ * result will cause a re-render.
+ *
+ * This hook follows the same Indexes object resolution rules as the useSliceIds
+ * hook.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param sliceId The Id of a possible Slice in the Index.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether a Slice with that Id exists.
+ * @category Indexes hooks
+ * @since v9.1.0
+ */
+export function useHasSlice(
+  indexId: Id,
+  sliceId: Id,
+  indexesOrIndexesId?: IndexesOrIndexesId,
+): boolean;
+
 /**
  * The useSliceRowIds hook gets the list of Row Ids in a given Slice, and
  * registers a listener so that any changes to that result will cause a

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

@@ -82,6 +82,7 @@ import type {
   IdOrNull,
   Ids,
   ParameterizedCallback,
+  Sorter,
 } from '../../common/with-schemas/index.d.ts';
 import type {
   Indexes,
@@ -140,6 +141,8 @@ import type {
   MapCell,
   MapValue,
   OptionalSchemas,
+  PartialRow,
+  PartialValues,
   Row,
   RowCountListener,
   RowIdsListener,
@@ -1901,6 +1904,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *   descending?: boolean,
  *   offset?: number,
  *   limit?: number,
+ *   sorterOrStoreOrStoreId?: Sorter | StoreOrStoreId,
  *   storeOrStoreId?: StoreOrStoreId,
  * ): Ids;
  * ```
@@ -2032,6 +2036,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
       descending?: boolean,
       offset?: number,
       limit?: number,
+      sorterOrStoreOrStoreId?: Sorter | StoreOrStoreId<Schemas>,
       storeOrStoreId?: StoreOrStoreId<Schemas>,
     ): Ids;
 
@@ -2039,7 +2044,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param storeOrStoreId The Store to be accessed: omit for the default context
  * Store, provide an Id for a named context Store, or provide an explicit
  * reference.
@@ -3573,14 +3579,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store hooks
  * @since v1.0.0
  */
-  useSetTablesCallback: <Parameter, SetTables = Tables<Schemas[0], true>>(
+  useSetTablesCallback: <Parameter>(
     getTables: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetTables>,
+    ) => Tables<Schemas[0], true>,
     getTablesDeps?: React.DependencyList,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (store: Store<Schemas>, tables: SetTables) => void,
+    then?: (store: Store<Schemas>, tables: Tables<Schemas[0], true>) => void,
     thenDeps?: React.DependencyList,
   ) => ParameterizedCallback<Parameter>;
 
@@ -3684,16 +3690,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   useSetTableCallback: <
     Parameter,
     TableId extends TableIdFromSchema<Schemas[0]>,
-    SetTable = Table<Schemas[0], TableId, true>,
   >(
     tableId: TableId | GetId<Schemas, Parameter, TableId>,
     getTable: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetTable>,
+    ) => Table<Schemas[0], TableId, true>,
     getTableDeps?: React.DependencyList,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (store: Store<Schemas>, table: SetTable) => void,
+    then?: (
+      store: Store<Schemas>,
+      table: Table<Schemas[0], TableId, true>,
+    ) => void,
     thenDeps?: React.DependencyList,
   ) => ParameterizedCallback<Parameter>;
 
@@ -3799,17 +3807,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store hooks
  * @since v1.0.0
  */
-  useSetRowCallback: <
-    Parameter,
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    SetRow = Row<Schemas[0], TableId, true>,
-  >(
+  useSetRowCallback: <Parameter, TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId | GetId<Schemas, Parameter, TableId>,
     rowId: Id | GetId<Schemas, Parameter, Id>,
-    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<SetRow>,
+    getRow: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => Row<Schemas[0], TableId, true>,
     getRowDeps?: React.DependencyList,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (store: Store<Schemas>, row: SetRow) => void,
+    then?: (store: Store<Schemas>, row: Row<Schemas[0], TableId, true>) => void,
     thenDeps?: React.DependencyList,
   ) => ParameterizedCallback<Parameter>;
 
@@ -3920,16 +3927,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store hooks
  * @since v1.0.0
  */
-  useAddRowCallback: <
-    Parameter,
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    AddRow = Row<Schemas[0], TableId, true>,
-  >(
+  useAddRowCallback: <Parameter, TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: TableId | GetId<Schemas, Parameter, TableId>,
-    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<AddRow>,
+    getRow: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => Row<Schemas[0], TableId, true>,
     getRowDeps?: React.DependencyList,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (rowId: Id | undefined, store: Store<Schemas>, row: AddRow) => void,
+    then?: (
+      rowId: Id | undefined,
+      store: Store<Schemas>,
+      row: Row<Schemas[0], TableId, true>,
+    ) => void,
     thenDeps?: React.DependencyList,
     reuseRowIds?: boolean,
   ) => ParameterizedCallback<Parameter>;
@@ -4041,17 +4051,19 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   useSetPartialRowCallback: <
     Parameter,
     TableId extends TableIdFromSchema<Schemas[0]>,
-    SetPartialRow = Row<Schemas[0], TableId, true>,
   >(
     tableId: TableId | GetId<Schemas, Parameter, TableId>,
     rowId: Id | GetId<Schemas, Parameter, Id>,
     getPartialRow: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetPartialRow>,
+    ) => PartialRow<Schemas[0], TableId>,
     getPartialRowDeps?: React.DependencyList,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (store: Store<Schemas>, partialRow: SetPartialRow) => void,
+    then?: (
+      store: Store<Schemas>,
+      partialRow: PartialRow<Schemas[0], TableId>,
+    ) => void,
     thenDeps?: React.DependencyList,
   ) => ParameterizedCallback<Parameter>;
 
@@ -4315,14 +4327,14 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store hooks
  * @since v3.0.0
  */
-  useSetValuesCallback: <Parameter, SetValues = Values<Schemas[1], true>>(
+  useSetValuesCallback: <Parameter>(
     getValues: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetValues>,
+    ) => Values<Schemas[1], true>,
     getValuesDeps?: React.DependencyList,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (store: Store<Schemas>, values: SetValues) => void,
+    then?: (store: Store<Schemas>, values: Values<Schemas[1], true>) => void,
     thenDeps?: React.DependencyList,
   ) => ParameterizedCallback<Parameter>;
 
@@ -4420,17 +4432,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store hooks
  * @since v3.0.0
  */
-  useSetPartialValuesCallback: <
-    Parameter,
-    SetPartialValues = Values<Schemas[1], true>,
-  >(
+  useSetPartialValuesCallback: <Parameter>(
     getPartialValues: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetPartialValues>,
+    ) => PartialValues<Schemas[1]>,
     getPartialValuesDeps?: React.DependencyList,
     storeOrStoreId?: StoreOrStoreId<Schemas>,
-    then?: (store: Store<Schemas>, partialValues: SetPartialValues) => void,
+    then?: (
+      store: Store<Schemas>,
+      partialValues: PartialValues<Schemas[1]>,
+    ) => void,
     thenDeps?: React.DependencyList,
   ) => ParameterizedCallback<Parameter>;
 
@@ -5957,7 +5969,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param listener The function that will be called whenever the sorted Row Ids
  * in the Table change.
  * @param listenerDeps An optional array of dependencies for the `listener`
@@ -8174,6 +8187,35 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  */
   useIndexIds(indexesOrIndexesId?: IndexesOrIndexesId<Schemas>): Ids;
 
+  /**
+ * The useHasIndex hook returns a boolean indicating whether a given Index
+ * exists in the Indexes object, and registers a listener so that any changes to
+ * that result will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasIndex(
+ *   indexId: Id,
+ *   indexesOrIndexesId?: IndexesOrIndexesId,
+ * ): boolean;
+ * ```
+ *
+ * This hook follows the same Indexes object resolution rules as the useIndexIds
+ * hook.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether an Index with that Id exists.
+ * @category Indexes hooks
+ * @since v9.1.0
+ */
+  useHasIndex: (
+    indexId: Id,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => boolean;
+
   /**
  * The useSliceIds hook gets the list of Slice Ids in an Index, and registers a
  * listener so that any changes to that result will cause a re-render.
@@ -8303,6 +8345,38 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
   ) => Ids;
 
+  /**
+ * The useHasSlice hook returns a boolean indicating whether a given Slice
+ * exists in an Index, and registers a listener so that any changes to that
+ * result will cause a re-render.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasSlice(
+ *   indexId: Id,
+ *   sliceId: Id,
+ *   indexesOrIndexesId?: IndexesOrIndexesId,
+ * ): boolean;
+ * ```
+ *
+ * This hook follows the same Indexes object resolution rules as the useSliceIds
+ * hook.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param sliceId The Id of a possible Slice in the Index.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether a Slice with that Id exists.
+ * @category Indexes hooks
+ * @since v9.1.0
+ */
+  useHasSlice: (
+    indexId: Id,
+    sliceId: Id,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => boolean;
+
   /**
  * The useSliceRowIds hook gets the list of Row Ids in a given Slice, and
  * registers a listener so that any changes to that result will cause a

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

@@ -38,6 +38,7 @@ import type {
   IdOrNull,
   Ids,
   ParameterizedCallback,
+  Sorter,
 } from '../common/index.d.ts';
 import type {
   Indexes,
@@ -1418,6 +1419,8 @@ export function useRowIds(
  * @param descending Whether the sorting should be in descending order.
  * @param offset The number of Row Ids to skip for pagination purposes, if any.
  * @param limit The maximum number of Row Ids to return, or `undefined` for all.
+ * @param sorter A custom function for comparing the sorting values, or
+ * `undefined` to use the default alphanumeric sorting.
  * @param storeOrStoreId The Store to be accessed: omit for the default context
  * Store, provide an Id for a named context Store, or provide an explicit
  * reference.
@@ -1441,6 +1444,7 @@ export function useRowIds(
  *     false,
  *     0,
  *     undefined,
+ *     undefined,
  *     store,
  *   );
  *   console.log(JSON.stringify(rowIds()));
@@ -1457,6 +1461,7 @@ export function useSortedRowIds(
   descending?: MaybeAccessor<boolean | undefined>,
   offset?: MaybeAccessor<number | undefined>,
   limit?: MaybeAccessor<number | undefined>,
+  sorter?: Sorter,
   storeOrStoreId?: MaybeAccessor<StoreOrStoreId | undefined>,
 ): Accessor<Ids>;
 
@@ -1464,7 +1469,8 @@ export function useSortedRowIds(
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param storeOrStoreId The Store to be accessed: omit for the default context
  * Store, provide an Id for a named context Store, or provide an explicit
  * reference.
@@ -4517,7 +4523,8 @@ export function useSortedRowIdsListener(
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param listener The function that will be called whenever the sorted Row Ids
  * in the Table change.
  * @param mutator An optional boolean that indicates that the listener mutates
@@ -6864,6 +6871,26 @@ export function useIndexIds(
   indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
 ): Accessor<Ids>;
 
+/**
+ * The useHasIndex primitive returns a boolean indicating whether a given Index
+ * exists in the Indexes object, and registers a listener so that any changes to
+ * that result will cause an update.
+ *
+ * This primitive follows the same Indexes object resolution rules as the
+ * useIndexIds primitive.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether an Index with that Id exists.
+ * @category Indexes primitives
+ * @since v9.1.0
+ */
+export function useHasIndex(
+  indexId: MaybeAccessor<Id>,
+  indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
+): Accessor<boolean>;
+
 /**
  * The useSliceIds primitive gets the list of Slice Ids in an Index, and
  * registers a listener so that any changes to that result will cause an update.
@@ -6951,6 +6978,28 @@ export function useSliceIds(
   indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
 ): Accessor<Ids>;
 
+/**
+ * The useHasSlice primitive returns a boolean indicating whether a given Slice
+ * exists in an Index, and registers a listener so that any changes to that
+ * result will cause an update.
+ *
+ * This primitive follows the same Indexes object resolution rules as the
+ * useSliceIds primitive.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param sliceId The Id of a possible Slice in the Index.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether a Slice with that Id exists.
+ * @category Indexes primitives
+ * @since v9.1.0
+ */
+export function useHasSlice(
+  indexId: MaybeAccessor<Id>,
+  sliceId: MaybeAccessor<Id>,
+  indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
+): Accessor<boolean>;
+
 /**
  * The useSliceRowIds primitive gets the list of Row Ids in a given Slice, and
  * registers a listener so that any changes to that result will cause an update.