reactjrx 1.6.2 → 1.7.0

package/dist/index.cjs

@@ -1493,6 +1493,101 @@ const useMutation = (query, options = {}) => {
   );
   return { ...result, mutate };
 };
+const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+function useQuery(key, fn, options = {}) {
+  const params$ = React.useRef(new rxjs.BehaviorSubject({ key, options }));
+  const queryRef = useLiveRef(fn);
+  const refetchSubject = useConstant(() => new rxjs.Subject());
+  const data$ = useConstant(
+    () => new rxjs.BehaviorSubject({
+      data: void 0,
+      error: void 0,
+      isLoading: false
+    })
+  );
+  React.useEffect(() => {
+    params$.current.next({
+      key,
+      options
+    });
+  }, [key, options]);
+  React.useEffect(() => {
+    const options$ = params$.current.pipe(
+      rxjs.map(({ options: options2 }) => options2),
+      rxjs.distinctUntilChanged(shallowEqual)
+    );
+    const key$ = params$.current.pipe(
+      rxjs.map(({ key: key2 }) => key2),
+      rxjs.distinctUntilChanged(arrayEqual)
+    );
+    const enabledOption$ = options$.pipe(
+      rxjs.map(({ enabled = true }) => enabled),
+      rxjs.distinctUntilChanged()
+    );
+    const executeFn$ = rxjs.combineLatest([
+      key$,
+      enabledOption$,
+      refetchSubject.pipe(rxjs.startWith(void 0))
+    ]).pipe(
+      rxjs.tap(([, enabled]) => {
+        if (!enabled) {
+          data$.next({
+            ...data$.getValue(),
+            isLoading: false
+          });
+        }
+      }),
+      rxjs.filter(([, enabled]) => enabled),
+      rxjs.map(([fn2]) => fn2)
+    );
+    const disabled$ = enabledOption$.pipe(rxjs.filter((v) => !v));
+    const sub = executeFn$.pipe(
+      rxjs.withLatestFrom(options$),
+      rxjs.tap(() => {
+        data$.next({
+          ...data$.getValue(),
+          error: void 0,
+          isLoading: true
+        });
+      }),
+      rxjs.switchMap(
+        ([, options2]) => rxjs.from(rxjs.defer(() => queryRef.current())).pipe(
+          querx(options2),
+          rxjs.map((response) => [response]),
+          rxjs.catchError((error) => {
+            return rxjs.of([void 0, error]);
+          }),
+          rxjs.takeUntil(disabled$)
+        )
+      ),
+      rxjs.tap(([response, error]) => {
+        data$.next({
+          ...data$.getValue(),
+          isLoading: false,
+          error,
+          data: response
+        });
+      })
+    ).subscribe({
+      next: () => {
+      },
+      complete: () => {
+        console.error("useQuerx has completed");
+      },
+      error: console.error
+    });
+    return () => sub.unsubscribe();
+  }, [refetchSubject, data$]);
+  const result = useObserve(data$, {
+    defaultValue: data$.getValue()
+  });
+  const refetch = React.useCallback(
+    () => refetchSubject.next(void 0),
+    [refetchSubject]
+  );
+  return { ...result, refetch };
+}
 exports.signal = signal;
 exports.useMutation = useMutation;
 exports.useObserve = useObserve;
+exports.useQuery = useQuery;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./lib/signal";
 export * from "./lib/useObserve";
 export * from "./lib/queries/useMutation";
+export * from "./lib/queries/useQuery";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { distinctUntilChanged, tap as tap$1, BehaviorSubject, defer, iif, timer, throwError, Subject as Subject$1, switchMap, from, map as map$1, catchError, of } from "rxjs";
+import { distinctUntilChanged, tap as tap$1, BehaviorSubject, defer, iif, timer, throwError, Subject as Subject$1, switchMap, from, map as map$1, catchError, of, combineLatest, startWith, filter, withLatestFrom, takeUntil } from "rxjs";
 import * as React from "react";
 import { useRef, useCallback, useSyncExternalStore, useMemo, useEffect } from "react";
 function shallowEqual(objA, objB) {
@@ -1475,8 +1475,103 @@ const useMutation = (query, options = {}) => {
   );
   return { ...result, mutate };
 };
+const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+function useQuery(key, fn, options = {}) {
+  const params$ = useRef(new BehaviorSubject({ key, options }));
+  const queryRef = useLiveRef(fn);
+  const refetchSubject = useConstant(() => new Subject$1());
+  const data$ = useConstant(
+    () => new BehaviorSubject({
+      data: void 0,
+      error: void 0,
+      isLoading: false
+    })
+  );
+  useEffect(() => {
+    params$.current.next({
+      key,
+      options
+    });
+  }, [key, options]);
+  useEffect(() => {
+    const options$ = params$.current.pipe(
+      map$1(({ options: options2 }) => options2),
+      distinctUntilChanged(shallowEqual)
+    );
+    const key$ = params$.current.pipe(
+      map$1(({ key: key2 }) => key2),
+      distinctUntilChanged(arrayEqual)
+    );
+    const enabledOption$ = options$.pipe(
+      map$1(({ enabled = true }) => enabled),
+      distinctUntilChanged()
+    );
+    const executeFn$ = combineLatest([
+      key$,
+      enabledOption$,
+      refetchSubject.pipe(startWith(void 0))
+    ]).pipe(
+      tap$1(([, enabled]) => {
+        if (!enabled) {
+          data$.next({
+            ...data$.getValue(),
+            isLoading: false
+          });
+        }
+      }),
+      filter(([, enabled]) => enabled),
+      map$1(([fn2]) => fn2)
+    );
+    const disabled$ = enabledOption$.pipe(filter((v) => !v));
+    const sub = executeFn$.pipe(
+      withLatestFrom(options$),
+      tap$1(() => {
+        data$.next({
+          ...data$.getValue(),
+          error: void 0,
+          isLoading: true
+        });
+      }),
+      switchMap(
+        ([, options2]) => from(defer(() => queryRef.current())).pipe(
+          querx(options2),
+          map$1((response) => [response]),
+          catchError((error) => {
+            return of([void 0, error]);
+          }),
+          takeUntil(disabled$)
+        )
+      ),
+      tap$1(([response, error]) => {
+        data$.next({
+          ...data$.getValue(),
+          isLoading: false,
+          error,
+          data: response
+        });
+      })
+    ).subscribe({
+      next: () => {
+      },
+      complete: () => {
+        console.error("useQuerx has completed");
+      },
+      error: console.error
+    });
+    return () => sub.unsubscribe();
+  }, [refetchSubject, data$]);
+  const result = useObserve(data$, {
+    defaultValue: data$.getValue()
+  });
+  const refetch = useCallback(
+    () => refetchSubject.next(void 0),
+    [refetchSubject]
+  );
+  return { ...result, refetch };
+}
 export {
   signal,
   useMutation,
-  useObserve
+  useObserve,
+  useQuery
 };

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

@@ -0,0 +1,7 @@
+import { QuerxOptions } from "./types";
+export declare function useQuery<T>(key: any[], fn: () => Promise<T>, options?: QuerxOptions): {
+    data: T | undefined;
+    isLoading: boolean;
+    error: unknown;
+    refetch: () => void;
+};

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

@@ -0,0 +1 @@
+export declare const arrayEqual: (a: any[], b: any[]) => boolean;

package/package.json

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