reactjrx 1.142.4 → 2.0.0

package/dist/lib/binding/useSubscribeEffect.d.ts

@@ -1,7 +1,31 @@
 import { SubscribeSource } from './useSubscribe/types';
-interface Option {
-    retryOnError?: boolean;
+export interface UseSubscribeEffectOptions {
+    /**
+     * Called on every error of the source, including the ones that are
+     * retried.
+     */
     onError?: (error: unknown) => void;
+    /**
+     * Whether to subscribe to the source again after an error:
+     * - `false` (default): the error ends the subscription;
+     * - `true`: retry without limit;
+     * - a number: retry at most that many times in a row;
+     * - a function: given the attempt (0 for the first retry) and the error,
+     *   returns whether to retry.
+     *
+     * The attempt count goes back to 0 once the source emits again.
+     */
+    retry?: boolean | number | ((attempt: number, error: unknown) => boolean);
+    /**
+     * Time to wait before each retry, in milliseconds, or a function of the
+     * attempt and the error. Retries always wait for a timer, so they never
+     * run synchronously, even with `0`. Defaults to an exponential backoff:
+     * 1 s, 2 s, 4 s… up to 30 s.
+     */
+    retryDelay?: number | ((attempt: number, error: unknown) => number);
 }
-export declare function useSubscribeEffect<T>(source: SubscribeSource<T>, options?: Option): void;
-export {};
+/**
+ * Subscribes to `source` while the component is mounted. Options are read
+ * at each error, so changing them never subscribes again.
+ */
+export declare function useSubscribeEffect<T>(source: SubscribeSource<T>, options?: UseSubscribeEffectOptions): void;

package/dist/lib/queries/createObservableQueryFn.d.ts

@@ -1,10 +1,15 @@
-import { QueryClient, QueryFunctionContext, QueryKey, skipToken } from '@tanstack/react-query';
+import { QueryFunctionContext, QueryKey, skipToken } from '@tanstack/react-query';
 import { Observable } from 'rxjs';
-import { QueryClient$ } from './QueryClientProvider$';
 export type ObservableQueryFn<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey> = ((context: QueryFunctionContext<TQueryKey>) => Observable<TQueryFnData>) | typeof skipToken | Observable<TQueryFnData>;
 /**
  * Bridges an Observable-based `queryFn` to the Promise-based `queryFn`
- * expected by TanStack Query. Shared by `useQuery$` and `useQueries$` so
- * both rely on the exact same subscription, caching and cancellation logic.
+ * expected by TanStack Query. Shared by `useQuery$` and `useQueries$`.
+ *
+ * As with TanStack's `streamedQuery`, the whole stream is one fetch: every
+ * value is written into the query as soon as the stream emits it, the query
+ * stays `fetching` until the stream completes, and the fetch then resolves
+ * with the last value. Cancelling the fetch (the last observer unmounting,
+ * `cancelQueries`, a refetch, the query leaving the cache) unsubscribes from
+ * the stream.
  */
-export declare function createObservableQueryFn<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey>(queryClient$: QueryClient$, queryClient: QueryClient | undefined, queryFn: ObservableQueryFn<TQueryFnData, TQueryKey> | undefined): typeof skipToken | ((context: QueryFunctionContext<TQueryKey>) => Promise<TQueryFnData>) | undefined;
+export declare function createObservableQueryFn<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey>(queryFn: ObservableQueryFn<TQueryFnData, TQueryKey> | undefined): typeof skipToken | ((context: QueryFunctionContext<TQueryKey>) => Promise<TQueryFnData>) | undefined;

package/dist/lib/queries/useQuery$.d.ts

@@ -2,4 +2,4 @@ import { DefaultError, QueryClient, QueryKey, UseQueryOptions } from '@tanstack/
 import { ObservableQueryFn } from './createObservableQueryFn';
 export declare function useQuery$<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>({ queryFn, ...options }: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, "queryFn"> & {
     queryFn: ObservableQueryFn<TQueryFnData, TQueryKey>;
-}, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<NoInfer<TData>, TError>;
+}, queryClient?: QueryClient): import('@tanstack/react-query').UseQueryResult<TData, TError>;

package/dist/lib/queries/useQuery$.tanstackClear.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/state/react/SignalContextProvider.d.ts

@@ -4,6 +4,6 @@ export type SignalContextType = SignalContext;
 export declare const SignalReactContext: import('react').Context<SignalContext>;
 export declare const SignalContextProvider: import('react').MemoExoticComponent<({ children }: {
     children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element>;
+}) => import('react').JSX.Element>;
 export declare const useSignalContext: () => SignalContext;
 export declare const useMakeOrRetrieveSignal: (virtualSignal?: VirtualSignal<unknown>) => import('../Signal').Signal<unknown, undefined> | undefined;

package/dist/tests/liveQuery.d.ts

@@ -17,4 +17,4 @@ export declare function createLiveQuerySource(initialItems: string[]): {
 };
 export declare function createWrapper(queryClient: QueryClient): ({ children }: {
     children: React.ReactNode;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.142.4",
+  "version": "2.0.0",
   "type": "module",
   "files": [
     "dist"
@@ -33,13 +33,13 @@
     "format": "npx @biomejs/biome check . --write"
   },
   "peerDependencies": {
-    "@tanstack/react-query": "5.x",
+    "@tanstack/react-query": "^5.85.1",
     "react": "19.x",
     "react-dom": "19.x",
     "rxjs": "*"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.15",
+    "@biomejs/biome": "2.5.15",
     "@rolldown/plugin-babel": "^0.2.3",
     "@tanstack/react-query-persist-client": "^5.96.2",
     "@testing-library/jest-dom": "^7.0.0",

package/dist/lib/queries/QueryClientProvider$.d.ts

@@ -1,41 +0,0 @@
-import { QueryClient, QueryKey } from '@tanstack/react-query';
-import { Observable, Subscription } from 'rxjs';
-type CacheEntry = {
-    queryKey: QueryKey;
-    query$: Observable<unknown>;
-    signal: AbortSignal;
-    sub: Subscription | undefined;
-    isCompleted: boolean;
-    lastData: {
-        value: unknown;
-    } | undefined;
-};
-export declare class QueryClient$ {
-    readonly queryClient: QueryClient;
-    /**
-     * Keyed by the query's own `queryKey` array: the one TanStack passes to
-     * `queryFn` and exposes as `query.queryKey`. Entries therefore match their
-     * query whatever its `queryKeyHashFn`, and nothing is hashed.
-     */
-    readonly queryMap: Map<QueryKey, CacheEntry>;
-    constructor(queryClient: QueryClient);
-    getQuery(queryKey: QueryKey): CacheEntry | undefined;
-    setQuery(queryKey: QueryKey, query$: Observable<unknown>, signal: AbortSignal): CacheEntry;
-    deleteQuery(queryKey: QueryKey, { cancelQuery }?: {
-        cancelQuery?: boolean;
-    }): void;
-    destroy(): void;
-}
-export declare const Context: import('react').Context<QueryClient$ | undefined>;
-/**
- * Must render **inside** TanStack `QueryClientProvider` (or equivalent).
- * Subscribes to that client's query cache so when a query is removed
- * (including via `queryClient.clear()`), matching `useQuery$` observable
- * entries are dropped.
- */
-export declare const QueryClientProvider$: import('react').MemoExoticComponent<({ children, client: _client, }: {
-    children: React.ReactNode;
-    client?: QueryClient$;
-}) => import("react/jsx-runtime").JSX.Element>;
-export declare const useQueryClient$: () => QueryClient$;
-export {};