`useSetParamValueCallback`

The useSetParamValueCallback primitive returns a parameterized callback that can be used to set a single parameter value for a query.

useSetParamValueCallback<Parameter>(
  queryId: MaybeAccessor<string> | GetId<Parameter>,
  paramId: MaybeAccessor<string> | GetId<Parameter>,
  getParamValue: (parameter: Parameter, queries: Queries) => ParamValue,
  queriesOrQueriesId?: MaybeAccessor<undefined | QueriesOrQueriesId>,
  then?: (queries: Queries, paramValue: ParamValue) => void,
): ParameterizedCallback<Parameter>

	Type	Description
`queryId`	`MaybeAccessor<string> \| GetId<Parameter>`	The `Id` of the query to update, or a `GetId` function that will return it.
`paramId`	`MaybeAccessor<string> \| GetId<Parameter>`	The `Id` of the parameter to update, or a `GetId` function that will return it.
`getParamValue`	`(parameter: Parameter, queries: Queries) => ParamValue`	A function which returns the parameter value that will be used to update the query, based on the parameter the callback will receive (and which is most likely a DOM event).
`queriesOrQueriesId?`	`MaybeAccessor<undefined \| QueriesOrQueriesId>`	The `Queries` object to be updated: omit for the default context `Queries` object, provide an `Id` for a named context `Queries` object, or provide an explicit reference.
`then?`	`(queries: Queries, paramValue: ParamValue) => void`	A function which is called after the mutation, with a reference to the `Queries` object and the parameter value used in the update.
returns	`ParameterizedCallback<Parameter>`	A parameterized callback for subsequent use.

This primitive is useful, for example, when creating an event handler that will update query parameters based on user interaction. In this case, the parameter will likely be the event, so that you can use data from it to update the query parameter.

The third parameter is a function which will produce the parameter value that will then be used to update the query in the callback.

For convenience, you can optionally provide a then function which will be called just after the query parameter has been updated.

Example

This example creates the TinyBase objects needed by the Solid primitive or component and calls it from within a reactive root.

import {createRoot} from 'solid-js';
import {
  createCheckpoints,
  createIndexes,
  createMetrics,
  createQueries,
  createRelationships,
  createStore,
} from 'tinybase';
import {useSetParamValueCallback} from 'tinybase/ui-solid';

createRoot((dispose) => {
  const store = createStore()
    .setTables({
      pets: {
        fido: {species: 'dog', color: 'brown', next: 'felix'},
        felix: {species: 'cat', color: 'black'},
      },
      species: {dog: {price: 5}, cat: {price: 4}},
    })
    .setValues({open: true});
  const metrics = createMetrics(store).setMetricDefinition(
    'highestPrice',
    'species',
    'max',
    'price',
  );
  const indexes = createIndexes(store).setIndexDefinition(
    'bySpecies',
    'pets',
    'species',
  );
  const relationships = createRelationships(store)
    .setRelationshipDefinition('petSpecies', 'pets', 'species', 'species')
    .setRelationshipDefinition('nextPet', 'pets', 'pets', 'next');
  const queries = createQueries(store).setQueryDefinition(
    'petColors',
    'pets',
    ({select, where, param}) => {
      select('color');
      where((getCell) => getCell('species') == param('species'));
    },
    {species: 'dog'},
  );
  const checkpoints = createCheckpoints(store);
  store.setCell('pets', 'fido', 'color', 'walnut');
  checkpoints.setCheckpoint('updated color');
  metrics.getMetric('highestPrice');
  indexes.getSliceIds('bySpecies');
  relationships.getRemoteRowId('petSpecies', 'fido');
  queries.getResultRowIds('petColors');
  useSetParamValueCallback('petColors', 'species', () => 'cat', queries)();
  dispose();
});

Since

v8.3.0