reactjrx 1.34.0 → 1.40.0

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

@@ -10,6 +10,6 @@ interface Option<R = undefined> {
 export declare function useObserve<T>(source: BehaviorSubject<T>): T;
 export declare function useObserve<T>(source: Observable<T>): T | undefined;
 export declare function useObserve<T>(source: () => Observable<T>, deps: DependencyList): T | undefined;
-export declare function useObserve<T, R = undefined>(source: Observable<T>, options: Option<R>): T | R;
-export declare function useObserve<T, R = undefined>(source: () => Observable<T>, options: Option<R>, deps: DependencyList): T | R;
+export declare function useObserve<T>(source: Observable<T>, options: Option<T>): T;
+export declare function useObserve<T>(source: () => Observable<T>, options: Option<T>, deps: DependencyList): T;
 export {};

package/dist/lib/logger.d.ts

@@ -0,0 +1,48 @@
+export declare function createLogger(env: string): {
+    namespaces: {
+        name: string;
+        style: {
+            backgroundColor: string;
+            color: string;
+        };
+    }[];
+    namespace(name: string, style?: {
+        backgroundColor: string;
+        color: string;
+    }): any;
+    printNamespaces(): {
+        namespaces: string;
+        styles: string[];
+    };
+    print(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    printWithoutNamespace(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    log(...message: any): any;
+    warn(...message: any): any;
+    error(...message: any): any;
+    group(...message: any): any;
+    groupEnd(): any;
+};
+export declare const Logger: {
+    namespaces: {
+        name: string;
+        style: {
+            backgroundColor: string;
+            color: string;
+        };
+    }[];
+    namespace(name: string, style?: {
+        backgroundColor: string;
+        color: string;
+    }): any;
+    printNamespaces(): {
+        namespaces: string;
+        styles: string[];
+    };
+    print(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    printWithoutNamespace(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    log(...message: any): any;
+    warn(...message: any): any;
+    error(...message: any): any;
+    group(...message: any): any;
+    groupEnd(): any;
+};

package/dist/lib/queries/client/cache/cacheClient.d.ts

@@ -0,0 +1,12 @@
+import { type createQueryStore } from "../store/createQueryStore";
+import { type QueryKey } from "../keys/types";
+type CallableUpdater<TQueryFnData> = (oldData: TQueryFnData | undefined) => TQueryFnData | undefined;
+export declare const createCacheClient: <TQueryFnData>({ queryStore }: {
+    queryStore: ReturnType<typeof createQueryStore>;
+}) => {
+    setQueryData: ({ queryKey, updater }: {
+        queryKey: QueryKey;
+        updater: TQueryFnData | CallableUpdater<TQueryFnData> | undefined;
+    }) => void;
+};
+export {};

package/dist/lib/queries/client/cache/invalidateCache.d.ts

@@ -0,0 +1,5 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryStore } from "../store/createQueryStore";
+export declare const invalidateCache: ({ queryStore }: {
+    queryStore: QueryStore;
+}) => MonoTypeOperatorFunction<string>;

package/dist/lib/queries/client/cache/logger.d.ts

@@ -0,0 +1,24 @@
+export declare const logger: {
+    namespaces: {
+        name: string;
+        style: {
+            backgroundColor: string;
+            color: string;
+        };
+    }[];
+    namespace(name: string, style?: {
+        backgroundColor: string;
+        color: string;
+    } | undefined): any;
+    printNamespaces(): {
+        namespaces: string;
+        styles: string[];
+    };
+    print(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    printWithoutNamespace(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    log(...message: any): any;
+    warn(...message: any): any;
+    error(...message: any): any;
+    group(...message: any): any;
+    groupEnd(): any;
+};

package/dist/lib/queries/client/cache/registerResultInCache.d.ts

@@ -0,0 +1,8 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryStore } from "../store/createQueryStore";
+import { type QueryOptions } from "../types";
+export declare const registerResultInCache: <T>({ queryStore, serializedKey, options }: {
+    queryStore: QueryStore;
+    serializedKey: string;
+    options: QueryOptions<T>;
+}) => MonoTypeOperatorFunction<T>;

package/dist/lib/queries/client/createClient.d.ts

@@ -0,0 +1,73 @@
+import { type Observable, BehaviorSubject } from "rxjs";
+import { type QueryOptions, type QueryFn, type QueryTrigger, type QueryResult } from "./types";
+import { type QueryKey } from "./keys/types";
+export declare const createClient: () => {
+    destroy: () => void;
+    pipeQueryResult: <R extends Partial<QueryResult<T>>, T>({ options$ }: {
+        key: string;
+        queryStore: {
+            set: (key: string, value: import("./store/createQueryStore").StoreObject<unknown>) => void;
+            get: <T_1>(serializedKey: string) => import("./store/createQueryStore").StoreObject<T_1> | undefined;
+            get$: (key: string) => Observable<import("./store/createQueryStore").StoreObject<unknown>>;
+            delete: (key: string) => void;
+            update: <T_2>(key: string, value: Partial<import("./store/createQueryStore").StoreObject<T_2>> | ((value: import("./store/createQueryStore").StoreObject<T_2>) => import("./store/createQueryStore").StoreObject<T_2>)) => void;
+            keys: () => IterableIterator<string>;
+            updateMany: (value: Partial<import("./store/createQueryStore").StoreObject<unknown>>, predicate?: (storeObject: import("./store/createQueryStore").StoreObject<unknown>) => boolean) => void;
+            addRunner: <T_3>(key: string, stream: Observable<{
+                options: QueryOptions<T_3>;
+            }>) => () => void;
+            store$: BehaviorSubject<Map<string, BehaviorSubject<import("./store/createQueryStore").StoreObject<unknown>>>>;
+            queryEvent$: Observable<import("./store/createQueryStore").QueryEvent>;
+            dispatchQueryEvent: (event: import("./store/createQueryStore").QueryEvent) => void;
+            queryTrigger$: Observable<import("./store/createQueryStore").QueryTriggerEvent>;
+            dispatchQueryTrigger: (event: import("./store/createQueryStore").QueryTriggerEvent) => void;
+            size: () => number;
+            destroy: () => void;
+        };
+        options$: Observable<QueryOptions<T>>;
+        refetch$: Observable<QueryTrigger>;
+    }) => import("rxjs").MonoTypeOperatorFunction<R>;
+    pipeQueryTrigger: <T_4>({ key }: {
+        key: string;
+        options$: Observable<QueryOptions<T_4>>;
+    }) => import("rxjs").MonoTypeOperatorFunction<QueryTrigger>;
+    setQueryData: ({ queryKey, updater }: {
+        queryKey: QueryKey;
+        updater: unknown;
+    }) => void;
+    invalidateQueries: ({ queryKey, exact, predicate }?: {
+        queryKey?: QueryKey | undefined;
+        exact?: boolean | undefined;
+        predicate?: ((storeObject: import("./store/createQueryStore").StoreObject<unknown>) => boolean) | undefined;
+    }) => void;
+    query$: <T_5>({ key, fn$: maybeFn$, fn: maybeFn, refetch$, options$ }: {
+        key: QueryKey;
+        fn?: QueryFn<T_5> | undefined;
+        fn$?: Observable<QueryFn<T_5>> | undefined;
+        refetch$?: Observable<{
+            ignoreStale: boolean;
+        }> | undefined;
+        options$?: Observable<QueryOptions<T_5>> | undefined;
+    }) => {
+        result$: Observable<QueryResult<T_5>>;
+    };
+    queryStore: {
+        set: (key: string, value: import("./store/createQueryStore").StoreObject<unknown>) => void;
+        get: <T_1>(serializedKey: string) => import("./store/createQueryStore").StoreObject<T_1> | undefined;
+        get$: (key: string) => Observable<import("./store/createQueryStore").StoreObject<unknown>>;
+        delete: (key: string) => void;
+        update: <T_2>(key: string, value: Partial<import("./store/createQueryStore").StoreObject<T_2>> | ((value: import("./store/createQueryStore").StoreObject<T_2>) => import("./store/createQueryStore").StoreObject<T_2>)) => void;
+        keys: () => IterableIterator<string>;
+        updateMany: (value: Partial<import("./store/createQueryStore").StoreObject<unknown>>, predicate?: (storeObject: import("./store/createQueryStore").StoreObject<unknown>) => boolean) => void;
+        addRunner: <T_3>(key: string, stream: Observable<{
+            options: QueryOptions<T_3>;
+        }>) => () => void;
+        store$: BehaviorSubject<Map<string, BehaviorSubject<import("./store/createQueryStore").StoreObject<unknown>>>>;
+        queryEvent$: Observable<import("./store/createQueryStore").QueryEvent>;
+        dispatchQueryEvent: (event: import("./store/createQueryStore").QueryEvent) => void;
+        queryTrigger$: Observable<import("./store/createQueryStore").QueryTriggerEvent>;
+        dispatchQueryTrigger: (event: import("./store/createQueryStore").QueryTriggerEvent) => void;
+        size: () => number;
+        destroy: () => void;
+    };
+};

package/dist/lib/queries/client/deduplication/deduplicate.d.ts

@@ -0,0 +1,3 @@
+import { type Observable } from "rxjs";
+import { type QueryStore } from "../store/createQueryStore";
+export declare const deduplicate: <T>(key: string, queryStore: QueryStore) => (source: Observable<T>) => Observable<T>;

package/dist/lib/queries/client/fetch/mapWithComplete.d.ts

@@ -0,0 +1,4 @@
+import { type OperatorFunction } from "rxjs";
+export declare const mapWithComplete: <T, R>(mapFn: ({ isComplete }: {
+    isComplete: boolean;
+}) => (data: T) => R) => OperatorFunction<T, R>;

package/dist/lib/queries/client/fetch/notifyQueryResult.d.ts

@@ -0,0 +1,3 @@
+import { type Observable, type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryOptions, type QueryResult } from "../types";
+export declare const notifyQueryResult: <R>(options$: Observable<QueryOptions<R>>) => MonoTypeOperatorFunction<Partial<QueryResult<R>>>;

package/dist/lib/queries/client/fetch/queryFetch.d.ts

@@ -0,0 +1,12 @@
+import { type Observable } from "rxjs";
+import { type QueryResult, type QueryFn, type QueryOptions, type QueryTrigger } from "../types";
+import { type createQueryStore } from "../store/createQueryStore";
+export declare const createQueryFetch: <T>({ options$, options, fn, queryStore, serializedKey, trigger, trigger$ }: {
+    fn: QueryFn<T>;
+    options$: Observable<QueryOptions<T>>;
+    options: QueryOptions<T>;
+    queryStore: ReturnType<typeof createQueryStore>;
+    serializedKey: string;
+    trigger: QueryTrigger;
+    trigger$: Observable<QueryTrigger>;
+}) => Observable<Partial<QueryResult<T>>>;

package/dist/lib/queries/client/invalidation/invalidationClient.d.ts

@@ -0,0 +1,12 @@
+import { type createQueryStore } from "../store/createQueryStore";
+import { type QueryKey } from "../keys/types";
+export declare const createInvalidationClient: ({ queryStore }: {
+    queryStore: ReturnType<typeof createQueryStore>;
+}) => {
+    invalidateQueries: ({ queryKey, exact, predicate }?: {
+        queryKey?: QueryKey | undefined;
+        exact?: boolean | undefined;
+        predicate?: ((storeObject: import("../store/createQueryStore").StoreObject<unknown>) => boolean) | undefined;
+    }) => void;
+    destroy: () => void;
+};

package/dist/lib/queries/client/invalidation/logger.d.ts

@@ -0,0 +1,24 @@
+export declare const logger: {
+    namespaces: {
+        name: string;
+        style: {
+            backgroundColor: string;
+            color: string;
+        };
+    }[];
+    namespace(name: string, style?: {
+        backgroundColor: string;
+        color: string;
+    } | undefined): any;
+    printNamespaces(): {
+        namespaces: string;
+        styles: string[];
+    };
+    print(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    printWithoutNamespace(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    log(...message: any): any;
+    warn(...message: any): any;
+    error(...message: any): any;
+    group(...message: any): any;
+    groupEnd(): any;
+};

package/dist/lib/queries/client/invalidation/markAsStale.d.ts

@@ -0,0 +1,8 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryStore } from "../store/createQueryStore";
+/**
+ * @important global query listener
+ */
+export declare const markAsStale: ({ queryStore }: {
+    queryStore: QueryStore;
+}) => MonoTypeOperatorFunction<string>;

package/dist/lib/queries/client/keys/compareKeys.d.ts

@@ -0,0 +1,4 @@
+import { type QueryKey } from "./types";
+export declare const compareKeys: (keyA: QueryKey, keyB: QueryKey, { exact }?: {
+    exact?: boolean | undefined;
+}) => boolean;

package/dist/lib/queries/client/keys/serializeKey.d.ts

@@ -0,0 +1,3 @@
+import { type QueryKey } from "./types";
+export declare const serializeObject: (object: any) => string;
+export declare const serializeKey: (key: QueryKey) => string;

package/dist/lib/queries/client/keys/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @important
+ * The empty key `[]` is a special case and will not
+ * be used to register cache, deduplicate, etc. It's a key
+ * that is supposed to be valid in its own context (not shareable).
+ *
+ * It is the equivalent of passing undefined key and can be used
+ * on isolated query when there is no need for key.
+ */
+export type QueryKey = readonly unknown[];

package/dist/lib/queries/client/operators.d.ts

@@ -0,0 +1,4 @@
+import { type Observable } from "rxjs";
+import { type QueryOptions, type QueryResult } from "./types";
+export declare const retryOnError: <T>(options: Pick<QueryOptions<T>, "retry">) => <T_1>(source: Observable<T_1>) => Observable<T_1>;
+export declare const mergeResults: <T>(stream$: Observable<Partial<QueryResult<T>>>) => Observable<QueryResult<T>>;

package/dist/lib/queries/client/refetch/client.d.ts

@@ -0,0 +1,18 @@
+import { type MonoTypeOperatorFunction, type Observable } from "rxjs";
+import { type createQueryStore } from "../store/createQueryStore";
+import { type QueryTrigger, type QueryOptions, type QueryResult } from "../types";
+export declare const createRefetchClient: ({ queryStore }: {
+    queryStore: ReturnType<typeof createQueryStore>;
+}) => {
+    pipeQueryResult: <R extends Partial<QueryResult<T>>, T>({ options$ }: {
+        key: string;
+        queryStore: ReturnType<typeof createQueryStore>;
+        options$: Observable<QueryOptions<T>>;
+        refetch$: Observable<QueryTrigger>;
+    }) => MonoTypeOperatorFunction<R>;
+    pipeQueryTrigger: <T_1>({ key }: {
+        key: string;
+        options$: Observable<QueryOptions<T_1>>;
+    }) => MonoTypeOperatorFunction<QueryTrigger>;
+    destroy: () => void;
+};

package/dist/lib/queries/client/store/createQueryStore.d.ts

@@ -0,0 +1,55 @@
+import { BehaviorSubject, type Observable } from "rxjs";
+import { type QueryKey } from "../keys/types";
+import { type QueryTrigger, type QueryOptions } from "../types";
+export interface StoreObject<T = unknown> {
+    queryKey: QueryKey;
+    isStale?: boolean;
+    lastFetchedAt?: number;
+    /**
+     * runners push themselves so we can retrieve various
+     * options, fn, etc on global listener.
+     * Each query runs on its own individual context so they
+     * have to register/deregister themselves into the global context.
+     */
+    runners: Array<Observable<{
+        options: QueryOptions<T>;
+    }>>;
+    cache_fnResult?: undefined | {
+        result: T;
+    };
+    deduplication_fn?: Observable<T>;
+}
+export type QueryEvent = {
+    type: "fetchSuccess";
+    key: string;
+} | {
+    type: "fetchError";
+    key: string;
+} | {
+    type: "queryDataSet";
+    key: string;
+};
+export interface QueryTriggerEvent {
+    key: string;
+    trigger: QueryTrigger;
+}
+export type QueryStore = ReturnType<typeof createQueryStore>;
+export declare const createQueryStore: () => {
+    set: (key: string, value: StoreObject) => void;
+    get: <T>(serializedKey: string) => StoreObject<T> | undefined;
+    get$: (key: string) => Observable<StoreObject<unknown>>;
+    delete: (key: string) => void;
+    update: <T_1>(key: string, value: Partial<StoreObject<T_1>> | ((value: StoreObject<T_1>) => StoreObject<T_1>)) => void;
+    keys: () => IterableIterator<string>;
+    updateMany: (value: Partial<StoreObject>, predicate?: (storeObject: StoreObject) => boolean) => void;
+    addRunner: <T_2>(key: string, stream: Observable<{
+        options: QueryOptions<T_2>;
+    }>) => () => void;
+    store$: BehaviorSubject<Map<string, BehaviorSubject<StoreObject<unknown>>>>;
+    queryEvent$: Observable<QueryEvent>;
+    dispatchQueryEvent: (event: QueryEvent) => void;
+    queryTrigger$: Observable<QueryTriggerEvent>;
+    dispatchQueryTrigger: (event: QueryTriggerEvent) => void;
+    size: () => number;
+    destroy: () => void;
+};

package/dist/lib/queries/client/store/debugger.d.ts

@@ -0,0 +1,3 @@
+import { type BehaviorSubject, type Observable } from "rxjs";
+import { type StoreObject } from "./createQueryStore";
+export declare const createDebugger: (store$: Observable<Map<string, BehaviorSubject<StoreObject>>>) => import("rxjs").Subscription;

package/dist/lib/queries/client/store/garbageCache.d.ts

@@ -0,0 +1,5 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryStore } from "../store/createQueryStore";
+export declare const garbageCache: ({ queryStore }: {
+    queryStore: QueryStore;
+}) => MonoTypeOperatorFunction<string>;

package/dist/lib/queries/client/store/initializeQueryInStore.d.ts

@@ -0,0 +1,8 @@
+import { type QueryKey } from "../keys/types";
+export declare const getInitialQueryEntity: ({ key }: {
+    key: QueryKey;
+}) => {
+    isStale: boolean;
+    queryKey: QueryKey;
+    runners: never[];
+};

package/dist/lib/queries/client/store/mapStoreQueryToRunnerOptions.d.ts

@@ -0,0 +1,4 @@
+import { type OperatorFunction } from "rxjs";
+import { type StoreObject } from "./createQueryStore";
+import { type QueryOptions } from "../types";
+export declare const mapStoreQueryToRunnerOptions: OperatorFunction<StoreObject, Array<QueryOptions<any>>>;

package/dist/lib/queries/client/store/queryListener.d.ts

@@ -0,0 +1,3 @@
+import { type QueryStore } from "./createQueryStore";
+import { type MonoTypeOperatorFunction } from "rxjs";
+export declare const createQueryListener: (store: QueryStore, onQuery: MonoTypeOperatorFunction<string>) => import("rxjs").Observable<string>;

package/dist/lib/queries/client/store/updateStoreWithQuery.d.ts

@@ -0,0 +1,14 @@
+import { type OperatorFunction, type Observable } from "rxjs";
+import { type QueryStore } from "./createQueryStore";
+import { type QueryOptions } from "../types";
+import { type QueryKey } from "../keys/types";
+export declare const updateStoreWithQuery: <T extends {
+    options: QueryOptions<R>;
+}, R>({ queryStore, serializedKey, runner$, key }: {
+    queryStore: QueryStore;
+    serializedKey: string;
+    key: QueryKey;
+    runner$: Observable<{
+        options: QueryOptions<R>;
+    }>;
+}) => OperatorFunction<T, [T, () => void]>;

package/dist/lib/queries/client/triggers.d.ts

@@ -0,0 +1,17 @@
+import { type Observable } from "rxjs";
+import { type QueryOptions } from "./types";
+import { type QueryStore } from "./store/createQueryStore";
+export declare const createQueryTrigger: <T>({ refetch$, options$, queryStore, key }: {
+    refetch$: Observable<{
+        ignoreStale: boolean;
+    }>;
+    options$: Observable<QueryOptions<T>>;
+    queryStore: QueryStore;
+    key: string;
+}) => Observable<import("./types").QueryTrigger | {
+    type: string;
+    ignoreStale: boolean;
+} | {
+    type: string;
+    ignoreStale: boolean;
+}>;

package/dist/lib/queries/client/types.d.ts

@@ -0,0 +1,48 @@
+import { type Observable } from "rxjs";
+import { type QueryKey } from "./keys/types";
+export interface QueryResult<T> {
+    data: {
+        result: T;
+    } | undefined;
+    fetchStatus: "fetching" | "paused" | "idle";
+    status: "loading" | "error" | "success";
+    error: unknown;
+}
+export interface Query {
+}
+export interface QueryCommand<T> {
+    key: QueryKey;
+    fn$?: Observable<QueryFn<T>>;
+    refetch$?: Observable<{
+        ignoreStale: boolean;
+    }>;
+    options$?: Observable<QueryOptions<T>>;
+}
+export type QueryFn<T> = (() => Promise<T>) | (() => Observable<T>) | Observable<T>;
+export interface QueryTrigger {
+    type: string;
+    ignoreStale: boolean;
+}
+export interface QueryOptions<T = unknown> {
+    enabled?: boolean;
+    retry?: false | number | ((attempt: number, error: unknown) => boolean);
+    /**
+     * @important
+     * The hook with the lowest value will be taken into account
+     */
+    staleTime?: number;
+    /**
+     * Force the new query to be marked as stale. Only on first trigger
+     */
+    markStale?: boolean;
+    cacheTime?: number;
+    /**
+     * @important
+     * interval is paused until the query finish fetching. This avoid infinite
+     * loop of refetch
+     */
+    refetchInterval?: number | false | ((data: QueryResult<T>["data"] | undefined, query: Query) => number | false);
+    terminateOnFirstResult?: boolean;
+    onError?: (error: unknown) => void;
+    onSuccess?: (data: T) => void;
+}

package/dist/lib/queries/react/Provider.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+import { type createClient } from "../client/createClient";
+export declare const Context: import("react").Context<{
+    client: ReturnType<typeof createClient>;
+}>;
+export declare const Provider: import("react").MemoExoticComponent<({ children, client }: {
+    children: ReactNode;
+    client: ReturnType<typeof createClient>;
+}) => import("react/jsx-runtime").JSX.Element>;
+export declare const useReactJrxProvider: () => {
+    client: ReturnType<typeof createClient>;
+};

package/dist/lib/queries/react/helpers.d.ts

@@ -0,0 +1,27 @@
+import { type QueryFn } from "../client/types";
+import { type UseQueryOptions } from "./types";
+export declare const useQueryParams: <T>({ queryKey, queryFn, ...options }: {
+    queryKey?: any[] | undefined;
+    queryFn?: QueryFn<T> | undefined;
+} & UseQueryOptions<T>) => {
+    current: import("rxjs").BehaviorSubject<{
+        queryKey: any[] | undefined;
+        options: {
+            refetchOnWindowFocus?: boolean | "always" | ((query: import("../client/types").Query) => boolean | "always") | undefined;
+            refetchOnReconnect?: boolean | "always" | ((query: import("../client/types").Query) => boolean | "always") | undefined;
+            refetchOnMount?: boolean | "always" | ((query: import("../client/types").Query) => boolean | "always") | undefined;
+            enabled?: boolean | undefined;
+            retry?: number | false | ((attempt: number, error: unknown) => boolean) | undefined;
+            staleTime?: number | undefined;
+            markStale?: boolean | undefined;
+            cacheTime?: number | undefined;
+            refetchInterval?: number | false | ((data: {
+                result: T;
+            } | undefined, query: import("../client/types").Query) => number | false) | undefined;
+            terminateOnFirstResult?: boolean | undefined;
+            onError?: ((error: unknown) => void) | undefined;
+            onSuccess?: ((data: T) => void) | undefined;
+        };
+        queryFn: QueryFn<T> | undefined;
+    }>;
+};

package/dist/lib/queries/react/triggers/activityTrigger.d.ts

@@ -0,0 +1,9 @@
+import { type Observable } from "rxjs";
+import { type UseQueryOptions } from "../types";
+export declare const createActivityTrigger: <T>(params$: Observable<{
+    options: UseQueryOptions<T>;
+}>) => Observable<{
+    ignoreStale: boolean;
+} | {
+    ignoreStale: boolean;
+}>;

package/dist/lib/queries/react/triggers/networkTrigger.d.ts

@@ -0,0 +1,7 @@
+import { type Observable } from "rxjs";
+import { type UseQueryOptions } from "../types";
+export declare const createNetworkTrigger: <T>(params$: Observable<{
+    options: UseQueryOptions<T>;
+}>) => Observable<{
+    ignoreStale: boolean;
+}>;

package/dist/lib/queries/react/types.d.ts

@@ -0,0 +1,13 @@
+import { type Query, type QueryOptions } from "../client/types";
+export interface UseQueryOptions<R = unknown> extends QueryOptions<R> {
+    refetchOnWindowFocus?: boolean | "always" | ((query: Query) => boolean | "always");
+    refetchOnReconnect?: boolean | "always" | ((query: Query) => boolean | "always");
+    refetchOnMount?: boolean | "always" | ((query: Query) => boolean | "always");
+}
+export interface UseQueryResult<R> {
+    data: R | undefined;
+    isLoading: boolean;
+    status: "success" | "error" | "loading";
+    error: unknown;
+    refetch: () => void;
+}

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

@@ -0,0 +1,6 @@
+import { type UseQueryResult, type UseQueryOptions } from "./types";
+import { type QueryFn } from "../client/types";
+export declare function useQuery<T>({ queryKey, queryFn, ...options }: {
+    queryKey?: any[];
+    queryFn?: QueryFn<T>;
+} & UseQueryOptions<T>): UseQueryResult<T>;

package/dist/lib/state/useSignal.d.ts

@@ -1,2 +1,2 @@
 import { type Signal } from "./signal";
-export declare const useSignal: <S, R>(signal: Signal<S, R>) => readonly [S | R, (stateOrUpdater: typeof import("./constants").SIGNAL_RESET | S | ((prev: S) => S)) => void];
+export declare const useSignal: <S>(signal: Signal<S, S>) => readonly [S, (stateOrUpdater: typeof import("./constants").SIGNAL_RESET | S | ((prev: S) => S)) => void];

package/dist/lib/state/useSignalValue.d.ts

@@ -1,2 +1,2 @@
 import { type Signal } from "./signal";
-export declare const useSignalValue: <S, R>(signal: Signal<S, R>, key?: string) => S | R;
+export declare const useSignalValue: <S>(signal: Signal<S, S>, key?: string) => S;

package/dist/lib/utils/difference.d.ts

@@ -0,0 +1 @@
+export declare const difference: <T>(a: T[], b: T[]) => T[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.34.0",
+  "version": "1.40.0",
   "type": "module",
   "files": [
     "dist"

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

@@ -1,23 +0,0 @@
-import { type ReactNode } from "react";
-import { type BehaviorSubject } from "rxjs";
-type CacheStore = Record<string, {
-    value: any;
-    date: number;
-    ttl: number;
-}>;
-export declare const Context: import("react").Context<{
-    cacheStore: {
-        current: BehaviorSubject<CacheStore>;
-    };
-    queryStore: import("./deduplication/useQueryStore").QueryStore;
-} | undefined>;
-export declare const Provider: import("react").MemoExoticComponent<({ children }: {
-    children: ReactNode;
-}) => import("react/jsx-runtime").JSX.Element>;
-export declare const useProvider: () => {
-    cacheStore?: {
-        current: BehaviorSubject<CacheStore>;
-    } | undefined;
-    queryStore?: import("./deduplication/useQueryStore").QueryStore | undefined;
-};
-export {};

package/dist/lib/queries/cache/useCreateCacheStore.d.ts

@@ -1,9 +0,0 @@
-type CacheStore = Record<string, {
-    value: any;
-    date: number;
-    ttl: number;
-}>;
-export declare const useCreateCacheStore: () => {
-    current: import("rxjs").BehaviorSubject<CacheStore>;
-};
-export {};

package/dist/lib/queries/deduplication/deduplicate.d.ts

@@ -1,3 +0,0 @@
-import { type Observable } from "rxjs";
-import { type QueryStore } from "./useQueryStore";
-export declare const deduplicate: <T>(key: string, queryStore?: QueryStore) => (source: Observable<T>) => Observable<T>;