reactjrx 1.2.0 → 1.7.0

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

@@ -0,0 +1,2 @@
+import { QuerxOptions } from "./types";
+export declare const retryFromOptions: (options: QuerxOptions) => <T>(source: import("rxjs").Observable<T>) => import("rxjs").Observable<T>;

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

@@ -0,0 +1,3 @@
+import { Observable } from "rxjs";
+import { QuerxOptions } from "./types";
+export declare const querx: <T>(options: QuerxOptions) => (source: Observable<T>) => Observable<T>;

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

@@ -0,0 +1,9 @@
+export type QuerxOptions = {
+    enabled?: boolean;
+    retry?: number | ((attempt: number, error: unknown) => boolean);
+    refetchOnWindowFocus?: boolean;
+    refetchOnMount?: boolean;
+    staleTime?: number;
+    onError?: (error: unknown) => void;
+    onSuccess?: () => void;
+};

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

@@ -0,0 +1,20 @@
+import { QuerxOptions } from "./types";
+/**
+ * @important
+ * Your mutation function is cancelled whenever you call a new mutate or
+ * when the component is unmounted. Same behavior will happens with your
+ * callback functions regarding unmounting. None of them will be called.
+ *
+ * If you provide an observable as a return it will be automatically cancelled
+ * as well during unmont or if called again. If you provide anything else you
+ * are in charge of controlling the flow.
+ *
+ * If you need to execute mutation independently of the component lifecycle or
+ * execute functions in parallel you should not use this hook.
+ */
+export declare const useMutation: <A, R>(query: (args: A) => Promise<R>, options?: QuerxOptions) => {
+    mutate: (args: A) => void;
+    data: R | undefined;
+    isLoading: boolean;
+    error: unknown;
+};

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/signal.d.ts

@@ -0,0 +1,3 @@
+export declare const signal: <T>({ default: defaultValue, }: {
+    default: T;
+}) => [() => T, (state: T | ((prev: T) => T)) => void];

package/dist/lib/useObserve.d.ts

@@ -0,0 +1,27 @@
+import { DependencyList } from "react";
+import { Observable } from "rxjs";
+/**
+ * Hook that subscribes to an RxJS Observable and
+ * synchronizes its latest value with an external store.
+ *
+ * @example
+ * function MyComponent(props) {
+ *   const source$ = useMemo(() => ... // Create and memoize an RxJS Observable here
+ *
+ *   const value = useObserve(source$);
+ *
+ *   // Render your component here
+ *   return <div>The value is: {value}</div>;
+ * }
+ *
+ * @remarks
+ * It's important to memoize the Observable using a hook
+ * such as `useMemo` or `useCallback` to ensure that the same
+ * Observable instance is passed to `useObserve` on every render.
+ * Otherwise, the hook will subscribe to a new Observable
+ * instance every time the component renders, leading to memory
+ * leaks and unexpected behavior.
+ */
+export declare function useObserve<T>(source$: Observable<T> | (() => Observable<T>), { defaultValue }: {
+    defaultValue: T;
+}, deps?: DependencyList): T;

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

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

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

@@ -0,0 +1,22 @@
+import { Observable } from "rxjs";
+export interface RetryBackoffConfig {
+    initialInterval: number;
+    maxRetries?: number;
+    maxInterval?: number;
+    resetOnSuccess?: boolean;
+    shouldRetry?: (attempt: number, error: any) => boolean;
+    backoffDelay?: (iteration: number, initialInterval: number) => number;
+}
+/** Calculates the actual delay which can be limited by maxInterval */
+export declare function getDelay(backoffDelay: number, maxInterval: number): number;
+/** Exponential backoff delay */
+export declare function exponentialBackoffDelay(iteration: number, initialInterval: number): number;
+/**
+ * Returns an Observable that mirrors the source Observable with the exception
+ * of an error. If the source Observable calls error, rather than propagating
+ * the error call this method will resubscribe to the source Observable with
+ * exponentially increasing interval and up to a maximum of count
+ * resubscriptions (if provided). Retrying can be cancelled at any point if
+ * shouldRetry returns false.
+ */
+export declare function retryBackoff(config: number | RetryBackoffConfig): <T>(source: Observable<T>) => Observable<T>;

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

@@ -0,0 +1 @@
+export declare function shallowEqual(objA: any, objB: any): boolean;

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

@@ -0,0 +1,21 @@
+/**
+ * useConstant hook returns a constant value computed by
+ * calling the provided function only once during the
+ * component's lifetime.
+ *
+ * @param {() => T} fn A function that computes and returns the constant value. The function is called only once, during the first render of the component.
+ * @returns {T} The constant value computed by the provided function.
+ *
+ * @example
+ * function MyComponent(props) {
+ *   const constantValue = useConstant(() => {
+ *     // Compute and return the constant value here
+ *     return "Hello, world!";
+ *   });
+ *
+ *   // Use the constant value in your component
+ *   return <div>{constantValue}</div>;
+ * }
+ *
+ */
+export declare const useConstant: <T>(fn: () => T) => T;

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

@@ -0,0 +1 @@
+export declare const useLiveRef: <T>(value: T) => import("react").MutableRefObject<T>;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.2.0",
+  "version": "1.7.0",
   "type": "module",
   "files": [
     "dist"
   ],
-  "main": "./dist/index.umd.cjs",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "exports": {
     ".": {
@@ -14,12 +14,14 @@
       "require": "./dist/index.umd.cjs"
     }
   },
+  "types": "./dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
+    "watch": "vite build --watch",
     "preview": "vite preview",
     "prepublishOnly": "npm run build",
     "semantic-release": "semantic-release"
@@ -37,9 +39,11 @@
     "semantic-release": "^21.0.1",
     "typescript": "^5.0.2",
     "vite": "^4.2.1",
+    "vite-plugin-dts": "^2.2.0",
     "vitest": "^0.29.8"
   },
   "dependencies": {
+    "@testing-library/react": "^14.0.0",
     "@types/node": "^18.15.11"
   },
   "repository": {

package/dist/index.umd.cjs

@@ -1,64 +0,0 @@
-(function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("rxjs"), require("react")) : typeof define === "function" && define.amd ? define(["exports", "rxjs", "react"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.reactjrx = {}, global.rxjs, global.react));
-})(this, function(exports2, rxjs, react) {
-  "use strict";
-  function shallowEqual(objA, objB) {
-    if (objA === null || objA === void 0 || objB === null || objB === void 0) {
-      return objA === objB;
-    }
-    if (typeof objA !== "object" || typeof objB !== "object") {
-      return objA === objB;
-    }
-    if (objA.constructor !== objB.constructor) {
-      return false;
-    }
-    const keysA = Object.keys(objA);
-    const keysB = Object.keys(objB);
-    if (keysA.length !== keysB.length) {
-      return false;
-    }
-    for (let i = 0; i < keysA.length; i++) {
-      const key = keysA[i];
-      if (key && objA[key] !== objB[key]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  function useObserve(source$, { defaultValue }, deps = []) {
-    const valueRef = react.useRef(defaultValue);
-    const subscribe = react.useCallback((next) => {
-      const sourceAsFn = typeof source$ === "function" ? source$ : () => source$;
-      const sub = sourceAsFn().pipe(
-        rxjs.distinctUntilChanged(shallowEqual),
-        rxjs.tap((value) => {
-          valueRef.current = value;
-        })
-      ).subscribe(next);
-      return () => sub.unsubscribe();
-    }, deps);
-    const getSnapshot = react.useCallback(() => valueRef.current, []);
-    return react.useSyncExternalStore(subscribe, getSnapshot);
-  }
-  const signal = ({
-    default: defaultValue
-  }) => {
-    const subject = new rxjs.BehaviorSubject(defaultValue);
-    const hook = () => useObserve(subject.asObservable(), { defaultValue }, []);
-    const setValue = (arg) => {
-      if (arg === subject.getValue())
-        return;
-      if (typeof arg === "function") {
-        const change = arg(subject.getValue());
-        if (change === subject.getValue())
-          return;
-        return subject.next(change);
-      }
-      return subject.next(arg);
-    };
-    return [hook, setValue];
-  };
-  exports2.signal = signal;
-  exports2.useObserve = useObserve;
-  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-});