QueriesObserver<TQueryData, TData> class Observers

Watches a list of queries at once and reports their results as one list, in the order the queries were given.

Use it when the number of queries is only known at run time — one query per id in a list, say. Each query is fetched, cached and settles on its own, exactly as with a QueryObserver per query (which is what this holds, one per entry); the listener receives the whole list of QueryResults whenever any of them changes. All queries share one data type TQueryData and one reported type TData; for a fixed handful of queries of different types, observe them separately and combine the results with combine on a record of results.

The lifecycle mirrors QueryObserver's:

• Construct with a client and a list of options. The queries are built or joined, but nothing is fetched yet.
• subscribe a listener. The first listener subscribes every member, which fetches each one that is due.
• setQueries replaces the list — members whose key is still there are kept (and handed their new options), new keys get a new member, and members whose key is gone are dropped.
• Stop: removing the last listener unsubscribes every member; destroy also releases the members themselves.

final observer = QueriesObserver(client, [
  for (final id in taskIds)
    QueryObserverOptions<Task>(
      queryKey: QueryKey(['tasks', id]),
      queryFn: (_) => api.task(id),
    ),
]);
final unsubscribe = observer.subscribe((results) {
  final loaded = results.whereType<QuerySuccess<Task>>().length;
  print('$loaded of ${results.length} tasks loaded');
});
// When the ids change: observer.setQueries([...]).
// When done:
unsubscribe();

The same key may appear more than once; each occurrence gets its own member, so two entries can apply different selects or options to the same cached data.