reactjrx 1.99.0 → 1.101.1

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

@@ -3,6 +3,7 @@ import { Observable, BehaviorSubject } from 'rxjs';
 interface Option<R = undefined> {
     defaultValue: R;
     unsubscribeOnUnmount?: boolean;
+    compareFn?: (a: R, b: R) => boolean;
 }
 export declare function useObserve<T>(source: BehaviorSubject<T>): T;
 export declare function useObserve<T>(source: Observable<T>): T | undefined;

package/dist/lib/queries/client/utils/makeObservable.d.ts

@@ -1,6 +1,20 @@
 import { Observable } from 'rxjs';
-export declare function makeObservable<Data>(fn: () => Observable<Data> | Data | Promise<Data>): Observable<Data>;
-export declare function makeObservable<Data>(fn: () => Data): Data extends Observable<infer ObservedData> ? Observable<ObservedData> : Data extends Promise<infer ThenData> ? Observable<ThenData> : Observable<Data>;
-export declare function makeObservable<Data>(fn: Data): Observable<Data>;
-export declare function makeObservable<Data>(fn: Promise<Data>): Observable<Data>;
+type FnReturnToObservable<T> = T extends Observable<infer ObservedData> ? ObservedData : T extends Promise<infer ThenData> ? ThenData : T;
 export declare function makeObservable<Data>(fn: Observable<Data>): Observable<Data>;
+export declare function makeObservable<Data>(fn: Promise<Data>): Observable<Data>;
+export declare function makeObservable<Data>(fn: Promise<Data> | Observable<Data>): Observable<Data>;
+export declare function makeObservable<Data>(fn: () => Promise<Data> | Observable<Data>): Observable<Data>;
+/**
+ * Generic factory
+ */
+export declare function makeObservable<TContext>(fn: () => Promise<TContext | undefined> | Observable<TContext | undefined> | TContext | undefined): Observable<undefined | TContext>;
+/**
+ * Generic factory
+ */
+export declare function makeObservable<Return>(fn: () => Return): Observable<FnReturnToObservable<Return>>;
+/**
+ * Generic factory OR Observable
+ */
+export declare function makeObservable<Data, Return>(fn: Observable<Data> | (() => Return)): Observable<Data | FnReturnToObservable<Return>>;
+export declare function makeObservable<Data>(fn: Data): Observable<Data>;
+export {};

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

@@ -0,0 +1 @@
+export { type Adapter } from './persistance/adapters/Adapter';

package/dist/lib/state/persistance/adapters/Adapter.d.ts

@@ -0,0 +1,6 @@
+export interface Adapter {
+    getItem: (key: string) => Promise<unknown>;
+    setItem: (key: string, value: any) => Promise<unknown>;
+    removeItem: (key: string) => Promise<unknown>;
+    clear: () => Promise<unknown>;
+}

package/dist/lib/state/persistance/adapters/MockAdapter.d.ts

@@ -0,0 +1,14 @@
+import { Adapter } from './Adapter';
+export declare class MockAdapter implements Adapter {
+    storage: Record<string, any>;
+    config: {
+        resolve: boolean;
+    };
+    constructor(storage?: Record<string, any>, config?: {
+        resolve: boolean;
+    });
+    getItem(key: string): Promise<any>;
+    setItem(_: string, __: any): Promise<unknown>;
+    removeItem(_: string): Promise<unknown>;
+    clear(): Promise<unknown>;
+}

package/dist/lib/state/persistance/adapters/createLocalStorageAdapter.d.ts

@@ -1,4 +1,4 @@
-import { Adapter } from '../types';
+import { Adapter } from './Adapter';
 export declare const createLocalStorageAdapter: ({ key }?: {
     key?: string;
 }) => Adapter;

package/dist/lib/state/persistance/adapters/createLocalforageAdapter.d.ts

@@ -1,4 +1,4 @@
-import { Adapter } from '../types';
+import { Adapter } from './Adapter';
 export declare const createLocalforageAdapter: (forage: {
     getItem: (key: string) => Promise<string | null>;
     setItem: (key: string, value: string) => Promise<string>;

package/dist/lib/state/persistance/helpers.d.ts

@@ -0,0 +1,11 @@
+import { Adapter } from './adapters/Adapter';
+import { SignalPersistenceConfig, PersistanceEntry } from './types';
+export declare const getNormalizedPersistanceValue: (unknownValue: unknown) => PersistanceEntry | undefined;
+export declare const persistValue: ({ adapter, config }: {
+    adapter: Adapter;
+    config: SignalPersistenceConfig<any>;
+}) => import('rxjs').Observable<unknown>;
+export declare function hydrateValueToSignal({ adapter, config }: {
+    adapter: Adapter;
+    config: SignalPersistenceConfig<any>;
+}): import('rxjs').Observable<unknown>;

package/dist/lib/state/persistance/persistSignals.d.ts

@@ -0,0 +1,20 @@
+import { SignalPersistenceConfig } from './types';
+import { Signal } from '../signal';
+import { Adapter } from './adapters/Adapter';
+export declare function persistSignals({ entries, onHydrated, adapter }: {
+    entries: Array<SignalPersistenceConfig<Signal<any, any, string>>>;
+    /**
+     * Triggered after first successful hydrate
+     */
+    onHydrated?: () => void;
+    /**
+     * Requires a stable instance otherwise the hydration
+     * process will start again. This is useful when you
+     * need to change adapter during runtime.
+     */
+    adapter: Adapter;
+}): import('rxjs').Observable<{
+    type: "hydrated";
+} | {
+    type: "persisted";
+}>;

package/dist/lib/state/persistance/persistSignals.test.d.ts

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

package/dist/lib/state/persistance/types.d.ts

@@ -1,11 +1,5 @@
 import { SignalValue, Signal } from '../signal';
 import { IDENTIFIER_PERSISTANCE_KEY } from './constants';
-export interface Adapter {
-    getItem: (key: string) => Promise<unknown>;
-    setItem: (key: string, value: any) => Promise<unknown>;
-    removeItem: (key: string) => Promise<unknown>;
-    clear: () => Promise<unknown>;
-}
 export interface PersistanceEntry {
     value: unknown;
     migrationVersion?: number;

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

@@ -0,0 +1,29 @@
+import { SignalPersistenceConfig } from '../persistance/types';
+import { Adapter } from '../persistance/adapters/Adapter';
+/**
+ * Make sure to pass stable reference of entries and adapter if you don't
+ * intentionally want to start over the process.
+ *
+ * `isHydrated` will be `true` after the first successful hydration. This value
+ * will be reset as soon as the adapter reference changes.
+ */
+export declare function usePersistSignals({ entries, onHydrated, adapter }: {
+    /**
+     * Passing a new list of entries will start over the process
+     * once the current one is finished. Use a stable reference to avoid
+     * inifite loop.
+     */
+    entries?: Array<SignalPersistenceConfig<any>>;
+    /**
+     * Triggered after first successful hydrate
+     */
+    onHydrated?: () => void;
+    /**
+     * Passing a new adapter reference will start over the process
+     * once the current one is finished. Use a stable reference to avoid
+     * inifite loop.
+     */
+    adapter?: Adapter;
+}): {
+    isHydrated: boolean;
+};

package/dist/lib/state/{useSignal.d.ts → react/useSignal.d.ts}

@@ -1,7 +1,7 @@
-import { Config } from './signal';
+import { Config } from '../signal';
 /**
  * Use it when:
  * - you need reactive state
  * - you don't need global state
  */
-export declare const useSignal: <T>(config: Config<T>) => readonly [T, import('./signal').Signal<T, T, undefined>];
+export declare const useSignal: <T>(config: Config<T>) => readonly [T, import('../signal').Signal<T, T, undefined>];

package/dist/lib/state/{useSignalValue.d.ts → react/useSignalValue.d.ts}

@@ -1,4 +1,4 @@
-import { ReadOnlySignal, Signal } from './signal';
+import { ReadOnlySignal, Signal } from '../signal';
 export declare function useSignalValue<DefaultValue, Value, Key, SelectValue>(signal: Signal<DefaultValue, Value, Key>, selector: (value: DefaultValue) => SelectValue): SelectValue;
 export declare function useSignalValue<DefaultValue, Value, Key>(signal: Signal<DefaultValue, Value, Key>): DefaultValue;
 export declare function useSignalValue<Value>(signal: ReadOnlySignal<Value>): Value;

package/dist/tests/utils.d.ts

@@ -1,7 +1,7 @@
 import { render } from '@testing-library/react';
 import { QueryClient, QueryClientConfig } from '../lib/queries/client/QueryClient';
 import { default as React } from 'react';
-export declare const waitForTimeout: (timeout: number) => Promise<unknown>;
+export declare const waitForTimeout: (timeout: number) => Promise<undefined>;
 /**
  * @see https://github.com/TanStack/query/blob/main/packages/react-query/src/__tests__/utils.tsx
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.99.0",
+  "version": "1.101.1",
   "type": "module",
   "files": [
     "dist"
@@ -28,7 +28,7 @@
     "preview": "vite preview",
     "prepublishOnly": "npm run build",
     "semantic-release": "semantic-release",
-    "test": "vitest",
+    "test": "vitest --typecheck",
     "test:ci": "vitest run",
     "tsc": "tsc",
     "lint": "eslint '**/*.{js,ts,tsx}'",
@@ -61,7 +61,7 @@
     "rollup-plugin-node-externals": "^7.0.1",
     "rxjs": "^7.8.0",
     "semantic-release": "^24.1.1",
-    "typescript": "5.6.2",
+    "typescript": "^5.6.2",
     "vite": "^5.1.3",
     "vite-plugin-dts": "^4.2.1",
     "vitest": "^1.3.0"

package/dist/lib/state/persistance/getNormalizedPersistanceValue.d.ts

@@ -1,2 +0,0 @@
-import { PersistanceEntry } from './types';
-export declare const getNormalizedPersistanceValue: (unknownValue: unknown) => PersistanceEntry | undefined;

package/dist/lib/state/persistance/usePersistSignals.d.ts

@@ -1,16 +0,0 @@
-import { Adapter, SignalPersistenceConfig } from './types';
-export declare function usePersistSignals({ entries, onReady, adapter }: {
-    entries?: Array<SignalPersistenceConfig<any>>;
-    /**
-     * Triggered after first successful hydrate
-     */
-    onReady?: () => void;
-    /**
-     * Requires a stable instance otherwise the hydration
-     * process will start again. This is useful when you
-     * need to change adapter during runtime.
-     */
-    adapter?: Adapter;
-}): {
-    isHydrated: boolean;
-};