@fozy-labs/rx-toolkit 0.4.18 → 0.5.0-rc.0

package/dist/query/index.d.ts

@@ -1,6 +1,6 @@
 export * from './api/createResource';
 export * from './api/createOperation';
-export * from './api/cleanAllQueriesCache';
+export * from './api/resetAllQueriesCache';
 export * from './SKIP_TOKEN';
 export * from './react/useResourceAgent';
 export * from './react/useResourceRef';

package/dist/query/index.js

@@ -1,6 +1,6 @@
 export * from './api/createResource';
 export * from './api/createOperation';
-export * from './api/cleanAllQueriesCache';
+export * from './api/resetAllQueriesCache';
 export * from './SKIP_TOKEN';
 export * from './react/useResourceAgent';
 export * from './react/useResourceRef';

package/dist/query/lib/IndirectMap.d.ts

@@ -14,6 +14,6 @@ export declare class IndirectMap<KEY, VALUE> {
      */
     delete(key: KEY): void;
     has(key: KEY): boolean;
-    get values(): IterableIterator<VALUE>;
+    values(): MapIterator<VALUE>;
 }
 export {};

package/dist/query/lib/IndirectMap.js

@@ -82,7 +82,7 @@ export class IndirectMap {
         }
         return has;
     }
-    get values() {
+    values() {
         return this._map.values();
     }
 }

package/dist/query/lib/ReactiveCache.d.ts

@@ -1,5 +1,5 @@
 import { Observable, Subject } from "rxjs";
-import { ReadableSignalLike } from "../../signals";
+import { ReadableSignalLike } from "../../signals/types";
 type Options<VALUE> = {
     /**
      * Начальное состояние кэша

package/dist/query/lib/ReactiveCache.js

@@ -56,7 +56,7 @@ export class ReactiveCache {
         };
     }
     get value() {
-        return this._state$.value;
+        return this._state$.getValue();
     }
     /**
      * Устанавливает новое значение в кэш и обновляет поток состояния.
@@ -74,7 +74,7 @@ export class ReactiveCache {
             return;
         this.closed = true;
         this._state$.complete();
-        this.onClean$.next(this._state$.value);
+        this.onClean$.next(this._state$.getValue());
         this.onClean$.complete();
     }
 }

package/dist/query/react/useOperationAgent.js

@@ -1,4 +1,4 @@
-import { useConstant, useEventHandler, useUnmount } from "../../common/react";
+import { useConstant, useEventHandler } from "../../common/react";
 import { useSignal } from "../../signals/react";
 export function useOperationAgent(op) {
     const agent = useConstant(() => op.createAgent());
@@ -6,7 +6,7 @@ export function useOperationAgent(op) {
     const trigger = useEventHandler((args) => {
         agent.initiate(args);
         return new Promise((resolve, reject) => {
-            const sub = agent.state$.subscribe((s) => {
+            const sub = agent.state$.obs.subscribe((s) => {
                 if (s.isDone && !s.isLoading) {
                     sub.unsubscribe();
                     if (s.isSuccess) {
@@ -19,8 +19,5 @@ export function useOperationAgent(op) {
             });
         });
     });
-    useUnmount(() => {
-        agent.complete();
-    }, [agent]);
     return [trigger, state];
 }

package/dist/query/react/useResourceAgent.js

@@ -1,5 +1,5 @@
 import React from "react";
-import { useConstant, useUnmount } from "../../common/react";
+import { useConstant } from "../../common/react";
 import { useSignal } from "../../signals/react";
 import { SKIP } from "../../query/SKIP_TOKEN";
 export function useResourceAgent(res, ...argss) {
@@ -16,8 +16,5 @@ export function useResourceAgent(res, ...argss) {
         prevArgsRef.current = args;
         agent.initiate(args);
     }
-    useUnmount(() => {
-        agent.complete();
-    });
     return useSignal(agent.state$);
 }

package/dist/query/types/Operation.types.d.ts

@@ -1,4 +1,4 @@
-import { ReadableSignalLike } from "../../signals";
+import { ReadableSignalLike } from "../../signals/types";
 import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
 import { ResourceDefinition, ResourceInstance } from "./Resource.types";
 /**
@@ -132,8 +132,6 @@ export type OperationAgentInstanse<D extends OperationDefinition> = {
     initiate(args: D["Args"]): void;
     /** Создает новый агент операции */
     createAgent(): OperationAgentInstanse<D>;
-    /** Завершает все текущие выполнения операции и очищает ресурсы */
-    complete(): void;
 };
 /**
  * Состояние выполнения операции

package/dist/query/types/Resource.types.d.ts

@@ -1,5 +1,5 @@
 import { Patch as ImmerPatch } from "immer";
-import { ReadableSignalLike } from "../../signals";
+import { ReadableSignalLike } from "../../signals/types";
 import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
 /**
  * Функция создания ресурса
@@ -71,8 +71,6 @@ export type ResourceAgentInstance<D extends ResourceDefinition> = {
     state$: ReadableSignalLike<ResourceQueryState<D>>;
     /** Инициирует запрос с указанными аргументами */
     initiate(args: D["Args"], force?: boolean): void;
-    /** Завершает работу агента, позволяя освободить ресурсы */
-    complete(): void;
     /** Сравнивает аргументы между собой */
     compareArgs(args1: D["Args"], args2: D["Args"]): unknown;
 };

package/dist/signals/base/Batcher.d.ts

@@ -2,5 +2,5 @@ export declare const Batcher: {
     scheduler(rang: number): {
         schedule: (fn: () => void) => void;
     };
-    batch<T>(fn: () => T): T;
+    run<T>(fn: () => T): T;
 };

package/dist/signals/base/Batcher.js

@@ -43,7 +43,7 @@ export const Batcher = {
             }
         };
     },
-    batch(fn) {
+    run(fn) {
         if (Scheduled.isLocked)
             return fn();
         Scheduled.isLocked = true;

package/dist/signals/base/DependencyTracker.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from "rxjs";
+export type DependencyRecord = {
+    /**
+     * Правило: getRang() должен вызываться только ПОСЛЕ подписки на obs,
+     * чтобы гарантировать корректный порядок рангов при ленивой инициализации.
+     */
+    getRang(): number;
+    obs: Observable<unknown>;
+    /**
+     * Зарезервировано для отладки и логирования.
+     */
+    meta?: any;
+};
+export declare class DependencyTracker {
+    private static _currentHandler;
+    static track(dep: DependencyRecord): void;
+    static start(handler: (arg: DependencyRecord) => void): () => void;
+}

package/dist/signals/base/DependencyTracker.js

@@ -0,0 +1,13 @@
+export class DependencyTracker {
+    static _currentHandler = null;
+    static track(dep) {
+        this._currentHandler?.(dep);
+    }
+    static start(handler) {
+        let prevHandler = this._currentHandler;
+        this._currentHandler = handler;
+        return () => {
+            this._currentHandler = prevHandler;
+        };
+    }
+}

package/dist/signals/base/Devtools.d.ts

@@ -1,5 +1,5 @@
 import { StateDevtoolsOptions } from "../../common/devtools";
 export declare const Devtools: {
-    createState<T>(initialValue: T, optionsDry?: StateDevtoolsOptions): import("../../common/devtools").DevtoolsStateLike<T> | null;
+    createState<T>(initialValue: T, optionsDry?: StateDevtoolsOptions): ((newState: T) => void) | null;
     readonly hasDevtools: boolean;
 };

package/dist/signals/base/Devtools.js

@@ -11,7 +11,19 @@ export const Devtools = {
         if (!createStateDevtools)
             return null;
         const key = createKey(options.name, options.base);
-        return createStateDevtools(key, initialValue);
+        let stateDevtools = options._skipValues?.includes(initialValue)
+            ? null
+            : createStateDevtools(key, initialValue);
+        return (newState) => {
+            if (options._skipValues?.includes(newState)) {
+                return;
+            }
+            if (!stateDevtools) {
+                stateDevtools = createStateDevtools(key, newState);
+                return;
+            }
+            stateDevtools(newState);
+        };
     },
     get hasDevtools() {
         return !!SharedOptions.DEVTOOLS?.state;

package/dist/signals/base/ReadonlySignal.d.ts

@@ -1,13 +1,11 @@
 import { Observable, Subscriber, TeardownLogic } from "rxjs";
-import type { ReadableSignalLike } from "./types";
+import { ReadableSignalFnLike, ReadableSignalLike } from "../../signals/types";
 import { SyncObservable } from "./SyncObservable";
-export declare class ReadonlySignal<T> extends SyncObservable<T> implements ReadableSignalLike<T> {
+export declare class ReadonlySignal<T> implements ReadableSignalLike<T> {
     protected rang: number;
+    readonly obs: SyncObservable<T>;
     constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
-    get value(): T;
-    peek(): T;
-    /**
-     * @deprecated
-     */
     get(): T;
+    peek(): T;
+    static create<T>(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic): ReadableSignalFnLike<T>;
 }

package/dist/signals/base/ReadonlySignal.js

@@ -1,21 +1,29 @@
 import { SyncObservable } from "./SyncObservable";
-import { Tracker } from "./Tracker";
-export class ReadonlySignal extends SyncObservable {
+import { DependencyTracker } from "./DependencyTracker";
+export class ReadonlySignal {
     rang = 0;
+    obs;
     constructor(subscribe) {
-        super(subscribe);
+        this.obs = new SyncObservable(subscribe);
     }
-    get value() {
-        Tracker.next(this.rang, this);
-        return super.value;
+    get() {
+        DependencyTracker.track({
+            getRang: () => this.rang,
+            obs: this.obs,
+        });
+        return this.obs.value;
     }
     peek() {
-        return super.value;
+        return this.obs.value;
     }
-    /**
-     * @deprecated
-     */
-    get() {
-        return this.value;
+    static create(subscribe) {
+        const signal = new ReadonlySignal(subscribe);
+        function readonlySignalFn() {
+            return signal.get();
+        }
+        readonlySignalFn.obs = signal.obs;
+        readonlySignalFn.peek = () => signal.peek();
+        readonlySignalFn.get = () => signal.get();
+        return readonlySignalFn;
     }
 }

package/dist/signals/base/index.d.ts

@@ -1,6 +1,5 @@
 export * from './Batcher';
+export * from './DependencyTracker';
 export * from './Devtools';
 export * from './ReadonlySignal';
 export * from './SyncObservable';
-export * from './Tracker';
-export * from './types';

package/dist/signals/base/index.js

@@ -1,6 +1,5 @@
 export * from './Batcher';
+export * from './DependencyTracker';
 export * from './Devtools';
 export * from './ReadonlySignal';
 export * from './SyncObservable';
-export * from './Tracker';
-export * from './types';

package/dist/signals/operators/index.d.ts

@@ -1,3 +1 @@
-export * from './filterUpdates';
-export * from './mapSignals';
 export * from './signalize';

package/dist/signals/operators/index.js

@@ -1,3 +1 @@
-export * from './filterUpdates';
-export * from './mapSignals';
 export * from './signalize';

package/dist/signals/operators/signalize.d.ts

@@ -1,3 +1,3 @@
 import { Observable } from "rxjs";
-import { ReadonlySignal } from "../base";
-export declare function signalize<T>(observable: Observable<T>): ReadonlySignal<T>;
+import { ReadableSignalFnLike } from "../../signals/types";
+export declare function signalize<T>(observable: Observable<T>): ReadableSignalFnLike<T>;

package/dist/signals/operators/signalize.js

@@ -1,6 +1,6 @@
 import { ReadonlySignal } from "../base";
 export function signalize(observable) {
-    return new ReadonlySignal((destination) => {
+    return ReadonlySignal.create((destination) => {
         return observable.subscribe(destination);
     });
 }

package/dist/signals/react/useSignal.d.ts

@@ -1,2 +1,6 @@
-import { ReadableSignalLike } from "../../signals";
-export declare function useSignal<T>(signal$: ReadableSignalLike<T>): T;
+import { Observable } from "rxjs";
+type SignalLike<T> = {
+    obs: Observable<T>;
+};
+export declare function useSignal<T>(signal$: SignalLike<T>): T;
+export {};

package/dist/signals/react/useSignal.js

@@ -1,23 +1,4 @@
-import React from "react";
-import { useEventHandler } from "../../common/react";
+import { useSyncObservable } from "../../common/react";
 export function useSignal(signal$) {
-    const doUpdateRef = React.useRef(false);
-    const subscribe = React.useCallback((update) => {
-        const subscription = signal$.subscribe(() => {
-            doUpdateRef.current = true;
-            queueMicrotask(() => {
-                if (!doUpdateRef.current)
-                    return;
-                update();
-            });
-        });
-        return () => {
-            subscription.unsubscribe();
-        };
-    }, [signal$]);
-    const getSnapshot = useEventHandler(() => {
-        doUpdateRef.current = false;
-        return signal$.peek();
-    });
-    return React.useSyncExternalStore(subscribe, getSnapshot);
+    return useSyncObservable(signal$.obs);
 }

package/dist/signals/signals/Computed.d.ts

@@ -1,14 +1,16 @@
-import { SubscriptionLike } from "rxjs";
-import { ReadableSignalLike } from "../base";
-import { Signal } from "./Signal";
 import { StateDevtoolsOptions } from "../../common/devtools";
-export declare class Computed<T> extends Signal<T> implements SubscriptionLike, ReadableSignalLike<T> {
-    private static _EMPTY;
+import { ComputeFn } from "../../signals/types";
+export declare class Computed<T> {
+    private _computeFn;
+    private options?;
+    private _ls;
+    readonly obs: import("rxjs").Observable<T>;
     private _effect;
-    constructor(computeFn: () => T, options?: StateDevtoolsOptions);
-    complete(): void;
-    /**
-     * @deprecated use 'complete()' instead
-     */
-    unsubscribe(): void;
+    constructor(_computeFn: () => T, options?: StateDevtoolsOptions | undefined);
+    get(): T;
+    peek(): T;
+    private _start;
+    private _stop;
+    private static _EMPTY;
+    static create<T>(computeFn: () => T, options?: StateDevtoolsOptions): ComputeFn<T>;
 }

package/dist/signals/signals/Computed.js

@@ -1,36 +1,89 @@
-import { Signal } from "./Signal";
+import { distinctUntilChanged, ReplaySubject, share, map, finalize } from "rxjs";
+import { DependencyTracker, Signal } from "../../signals";
 import { Effect } from "./Effect";
-export class Computed extends Signal {
-    static _EMPTY = Symbol('empty');
-    _effect;
-    constructor(computeFn, options) {
+export class Computed {
+    _computeFn;
+    options;
+    _ls;
+    obs;
+    _effect = null;
+    constructor(_computeFn, options) {
+        this._computeFn = _computeFn;
+        this.options = options;
+        const lsOptions = {
+            base: Computed.name,
+            ...(typeof options === 'string' ? { name: options } : options),
+            _skipValues: [Computed._EMPTY],
+        };
+        this._ls = new Signal(Computed._EMPTY, lsOptions);
+        this.obs = this._ls.obs.pipe(map((value) => {
+            if (value === Computed._EMPTY) {
+                return this._start();
+            }
+            return value;
+        }), distinctUntilChanged(), finalize(() => {
+            this._stop();
+        }), share({
+            connector: () => new ReplaySubject(1),
+            resetOnRefCountZero: true,
+            resetOnComplete: true,
+        }));
+    }
+    get() {
+        DependencyTracker.track({
+            getRang: () => {
+                if (!this._effect) {
+                    throw new Error('Effect in not started. Possibly maximum call stack size exceeded.');
+                }
+                return this._effect._getRang();
+            },
+            obs: this.obs,
+        });
+        const v = this._ls.peek();
+        if (v === Computed._EMPTY) {
+            return this._computeFn();
+        }
+        return v;
+    }
+    peek() {
+        const v = this._ls.peek();
+        if (v === Computed._EMPTY) {
+            return this._computeFn();
+        }
+        return v;
+    }
+    _start() {
         let initialValue = Computed._EMPTY;
-        const effect = new Effect(() => {
+        this._effect = new Effect(() => {
             if (initialValue === Computed._EMPTY) {
-                initialValue = computeFn();
+                initialValue = this._computeFn();
+                this._ls.set(initialValue);
                 return;
             }
-            this._rang = effect._rang;
-            this.value = computeFn();
-        }, () => {
-            this.complete();
+            this._ls.set(this._computeFn());
         });
-        super(initialValue, {
-            base: 'Computed',
-            ...(typeof options === 'string' ? { name: options } : options)
-        });
-        this._effect = effect;
+        if (initialValue === Computed._EMPTY) {
+            throw new Error('Computed value is not initialized');
+        }
+        return initialValue;
     }
-    complete() {
-        if (this.closed)
-            return;
-        this._effect.complete();
-        super.complete();
+    _stop() {
+        if (this._effect) {
+            this._effect.unsubscribe();
+            this._effect = null;
+        }
+        this._ls.set(Computed._EMPTY);
     }
-    /**
-     * @deprecated use 'complete()' instead
-     */
-    unsubscribe() {
-        this.complete();
+    // === static ===
+    static _EMPTY = Symbol('empty');
+    static create(computeFn, options) {
+        const lc = new Computed(computeFn, options);
+        function computedFn() {
+            return lc.get();
+        }
+        computedFn.peek = () => lc.peek();
+        computedFn.get = () => lc.get();
+        computedFn.obs = lc.obs;
+        return computedFn;
     }
 }

package/dist/signals/signals/Effect.d.ts

@@ -1,19 +1,23 @@
 import { SubscriptionLike } from "rxjs";
+type Teardown = () => void;
+type EffectFn = () => void | Teardown;
 export declare class Effect implements SubscriptionLike {
-    private _onComplete?;
     private _subscriptions;
     private _teardown?;
-    protected readonly _scopeDestroyedSub: import("rxjs").Subscription | undefined;
     closed: boolean;
-    _rang: number;
-    constructor(effectFn: (ctx: (fn: () => void) => void) => void | (() => void), _onComplete?: (() => void) | undefined);
+    private _rang;
+    constructor(effectFn: EffectFn);
     /**
      * Выполняет функцию в tracked-контексте, подписываясь на Tracker.
      */
     private _runInTrackedContext;
-    complete(): void;
+    unsubscribe(): void;
+    _getRang(): number;
     /**
-     * @deprecated Use `complete()` method instead.
+     * @deprecated Use `unsubscribe()` method instead.
      */
-    unsubscribe(): void;
+    complete(): void;
+    private _callTeardown;
+    static create(effectFn: EffectFn): Effect;
 }
+export {};