@fozy-labs/rx-toolkit 0.4.1 → 0.4.3

package/dist/query/core/Resource/ResourceRef.js

@@ -1,3 +1,5 @@
+import { applyPatches, enablePatches, produceWithPatches } from "immer";
+enablePatches();
 export class ResourceRef {
     _resource;
     _args;
@@ -36,13 +38,105 @@ export class ResourceRef {
             };
         }
         const value = cacheItem.value;
-        this._resource.updateData(this._args, updateFn, { cache: cacheItem });
+        this._resource.updateData_legacy(this._args, updateFn, { cache: cacheItem });
         return {
             rollback: () => {
-                this._resource.updateData(this._args, () => value.data, { cache: cacheItem });
+                this._resource.updateData_legacy(this._args, () => value.data, { cache: cacheItem });
             }
         };
     }
+    patch(patchFn) {
+        let isSkipped = true;
+        const reapplyFn = (data, savedData, transactions) => {
+            if (!transactions || transactions.length === 0) {
+                return { data, transactions, savedData };
+            }
+            // Все валидные committed - пропускаем и убираем из очереди
+            // Все aborted - применяем и убираем из очереди
+            // Все pending - применяем и оставляем в очереди
+            // Все commited (которые после pending) - применяем, но оставляем в очереди
+            // Все aborted (которые после pending) - откатываем, но оставляем в очереди
+            // Те после применения всех транзакций, очередь должна начинаться с первой pending транзакции (если есть), включая все, что после неё.
+            let newSavedData = savedData ?? data;
+            let currentData = savedData ?? data;
+            const remainingTransactions = [];
+            let foundPending = false;
+            transactions.forEach((transaction) => {
+                if (transaction.status === 'pending') {
+                    foundPending = true;
+                    // Применяем pending транзакцию и оставляем в очереди
+                    currentData = applyPatches(currentData, transaction.patches);
+                    remainingTransactions.push(transaction);
+                }
+                else if (foundPending) {
+                    // После pending транзакции
+                    if (transaction.status === 'committed') {
+                        // Применяем и оставляем в очереди
+                        currentData = applyPatches(currentData, transaction.patches);
+                        remainingTransactions.push(transaction);
+                    }
+                    else if (transaction.status === 'aborted') {
+                        // Откатываем и оставляем в очереди
+                        currentData = applyPatches(currentData, transaction.inversePatches);
+                        remainingTransactions.push(transaction);
+                    }
+                }
+                else {
+                    // До первой pending транзакции
+                    if (transaction.status === 'committed') {
+                        // Применяем и убираем из очереди
+                        const patches = transaction.patches;
+                        currentData = applyPatches(currentData, patches);
+                        newSavedData = currentData;
+                    }
+                }
+            });
+            const hasTransactions = remainingTransactions.length > 0;
+            return {
+                data: currentData,
+                transactions: hasTransactions ? remainingTransactions : null,
+                savedData: hasTransactions ? newSavedData : null,
+            };
+        };
+        const reapplyTransactions = () => {
+            this._resource.update(this._args, reapplyFn, { cache: this._cacheItem ?? undefined });
+        };
+        const transaction = {
+            patches: [],
+            inversePatches: [],
+            status: 'pending',
+            abort() {
+                if (this.status !== 'pending')
+                    return;
+                this.status = 'aborted';
+                reapplyTransactions();
+            },
+            commit() {
+                if (this.status !== 'pending')
+                    return;
+                this.status = 'committed';
+                reapplyTransactions();
+            }
+        };
+        const updateFn = (data, savedData, transactions) => {
+            isSkipped = false;
+            const [newData, patches, inversePatches] = produceWithPatches(data, (draft) => patchFn(draft));
+            transaction.patches = patches;
+            transaction.inversePatches = inversePatches;
+            const newTransactions = [...(transactions ?? [])];
+            newTransactions.push(transaction);
+            return {
+                data: newData,
+                transactions: newTransactions,
+                savedData: savedData ?? data,
+            };
+        };
+        this._cacheItem = this._resource.update(this._args, updateFn, { cache: this._cacheItem ?? undefined });
+        if (isSkipped) {
+            return null;
+        }
+        return transaction;
+    }
     create(data) {
         throw new Error("Method not implemented.");
     }

package/dist/query/index.d.ts

@@ -1,7 +1,6 @@
 export * from './api/createResource';
 export * from './api/createOperation';
-export * from './api/DefaultOptions';
-export * from './api/createDevtools';
 export * from './SKIP_TOKEN';
 export * from './react/useResourceAgent';
+export * from './react/useResourceRef';
 export * from './react/useOperationAgent';

package/dist/query/index.js

@@ -1,7 +1,6 @@
 export * from './api/createResource';
 export * from './api/createOperation';
-export * from './api/DefaultOptions';
-export * from './api/createDevtools';
 export * from './SKIP_TOKEN';
 export * from './react/useResourceAgent';
+export * from './react/useResourceRef';
 export * from './react/useOperationAgent';

package/dist/query/lib/IndirectMap.js

@@ -1,4 +1,4 @@
-import { shallowEqual } from "../../query/lib/shallowEqual";
+import { shallowEqual } from "./shallowEqual";
 export class IndirectMap {
     _compareObjectsFn;
     _compareCache = new WeakMap();

package/dist/query/lib/ReactiveCache.js

@@ -1,5 +1,5 @@
 import { finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
-import { Signal } from "../../signal";
+import { Signal } from "../../signals";
 /**
  * Класс `ReactiveCache` представляет собой реактивный кэш,
  * который позволяет управлять состоянием и временем жизни кэшированных данных.
@@ -44,7 +44,7 @@ export class ReactiveCache {
      */
     constructor(options) {
         this._cacheLifeTime = options.cacheLifeTime || 60_000;
-        this._state$ = new Signal(options.initialState);
+        this._state$ = new Signal(options.initialState, { disableDevtools: true });
         this._value = options.initialState;
         this.spy$ = this._state$.pipe(takeUntil(this.onClean$));
         this.value$ = this._state$.pipe(finalize(() => {

package/dist/query/react/useOperationAgent.d.ts

@@ -1,5 +1,4 @@
-import { OperationAgentInstanse, OperationDefinition, OperationQueryState } from "../types/Operation.types";
-import { Prettify } from "../types/shared.types";
+import type { Prettify, OperationAgentInstanse, OperationDefinition, OperationQueryState } from "../../query/types";
 type WithAgent<D extends OperationDefinition> = {
     createAgent: () => OperationAgentInstanse<D>;
 };

package/dist/query/react/useOperationAgent.js

@@ -1,4 +1,5 @@
-import { useConstant, useEventHandler, useSignal } from "../../react-hooks";
+import { useConstant, useEventHandler } from "../../common/react";
+import { useSignal } from "../../signals/react";
 export function useOperationAgent(op) {
     const agent = useConstant(() => op.createAgent());
     const state = useSignal(agent.state$);

package/dist/query/react/useResourceAgent.d.ts

@@ -1,6 +1,5 @@
-import { ResourceAgentInstance, ResourceDefinition, ResourceQueryState } from "../types/Resource.types";
-import { Prettify } from "../types/shared.types";
-import { SKIP } from "../SKIP_TOKEN";
+import { Prettify, ResourceAgentInstance, ResourceDefinition, ResourceQueryState } from "../../query/types";
+import { SKIP } from "../../query/SKIP_TOKEN";
 type WithAgent<D extends ResourceDefinition> = {
     createAgent: () => ResourceAgentInstance<D>;
 };

package/dist/query/react/useResourceAgent.js

@@ -1,7 +1,8 @@
 import React from "react";
-import { useConstant, useSignal } from "../../react-hooks";
-import { shallowEqual } from "../lib/shallowEqual";
-import { SKIP } from "../SKIP_TOKEN";
+import { useConstant } from "../../common/react";
+import { useSignal } from "../../signals/react";
+import { shallowEqual } from "../../query/lib/shallowEqual";
+import { SKIP } from "../../query/SKIP_TOKEN";
 export function useResourceAgent(res, ...argss) {
     const args = (argss[0] === SKIP ? SKIP : argss[0]);
     const agent = useConstant(() => {

package/dist/query/react/useResourceRef.d.ts

@@ -0,0 +1,5 @@
+import { SKIP } from "../../query/SKIP_TOKEN";
+import type { Prettify, ResourceDefinition, ResourceInstance, ResourceRefInstanse } from "../../query/types";
+type Result<D extends ResourceDefinition> = Prettify<ResourceRefInstanse<D>> | null;
+export declare function useResourceRef<D extends ResourceDefinition>(res: ResourceInstance<D>, ...argss: D['Args'] extends void ? [] | [typeof SKIP] : [D['Args'] | typeof SKIP]): Result<D>;
+export {};

package/dist/query/react/useResourceRef.js

@@ -0,0 +1,8 @@
+import React from "react";
+import { SKIP } from "../../query/SKIP_TOKEN";
+export function useResourceRef(res, ...argss) {
+    const args = (argss[0] === SKIP ? SKIP : argss[0]);
+    return React.useMemo(() => {
+        return res.createRef(args);
+    }, [args]);
+}

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

@@ -1,5 +1,5 @@
-import { ReadableSignalLike } from "../../signal";
-import { FallbackOnNever } from "../../query/types/shared.types";
+import { ReadableSignalLike } from "../../signals";
+import { FallbackOnNever } from "./shared.types";
 import { ResourceDefinition, ResourceInstance } from "./Resource.types";
 /**
  * Функция создания операции
@@ -20,21 +20,62 @@ export type OperationCreateOptions<D extends OperationDefinition> = {
  * Настройки связи операции с ресурсом
  */
 export type LinkOptions<D extends OperationDefinition, RD extends ResourceDefinition> = {
+    /**
+     * Целевой ресурс, с которым связывается операция
+     * @required
+     */
     resource: ResourceInstance<RD>;
+    /**
+     * Функция для получения аргументов ресурса из аргументов операции.
+     * Используется для определения какой именно элемент в кэше ресурса нужно обновить
+     * @required
+     */
     forwardArgs: (args: D["Args"]) => RD["Args"];
+    /**
+     * Флаг для инвалидации (очистки) кэша ресурса после выполнения операции.
+     * При true - кэш будет очищен и ресурс будет перезагружен при следующем обращении
+     * @optional @default false
+     */
     invalidate?: boolean;
+    /**
+     * Флаг для блокировки ресурса во время выполнения операции.
+     * При true - ресурс будет заблокирован и не сможет выполнять новые запросы
+     * @optional @default false
+     */
     lock?: boolean;
+    /**
+     * Функция для обновления кэша ресурса после успешного выполнения операции.
+     * Получает draft объект для мутации, аргументы операции и результат операции
+     * @optional
+     */
     update?: (tools: {
+        /** Immer draft объект для мутации кэша ресурса */
         draft: RD["Data"];
+        /** Аргументы, с которыми была вызвана операция */
         args: D["Args"];
+        /** Результат выполнения операции */
         data: D["Data"];
     }) => void | RD["Data"] | Promise<RD["Data"]>;
+    /**
+     * Функция для оптимистичного обновления кэша ресурса ДО выполнения операции.
+     * Позволяет обновить UI немедленно, до получения ответа от сервера
+     * @optional
+     */
     optimisticUpdate?: (tools: {
+        /** Immer draft объект для мутации кэша ресурса */
         draft: RD["Data"];
+        /** Аргументы, с которыми была вызвана операция */
         args: D["Args"];
-    }) => void | RD["Data"] | Promise<D["Data"]>;
+    }) => void | RD["Data"] | Promise<RD["Data"]>;
+    /**
+     * Функция для создания нового элемента в кэше ресурса.
+     * Используется когда операция создает новую сущность, которую нужно добавить в кэш
+     * @optional
+     */
     create?: (tools: {
+        /** Аргументы, с которыми была вызвана операция */
         args: D["Args"];
+        /** Результат выполнения операции */
         data: D["Data"];
     }) => RD["Data"] | Promise<RD["Data"]>;
 };

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

@@ -1,5 +1,6 @@
-import { ReadableSignalLike } from "../../signal";
-import { FallbackOnNever } from "../../query/types/shared.types";
+import { Patch as ImmerPatch } from "immer";
+import { ReadableSignalLike } from "../../signals";
+import { FallbackOnNever } from "./shared.types";
 /**
  * Функция создания ресурса
  */
@@ -72,6 +73,16 @@ export type ResourceQueryState<D extends ResourceDefinition> = {
     /** Аргументы запроса */
     args: D["Args"] | undefined;
 };
+/**
+ * Транзакция ресурса
+ */
+export type ResourceTransaction = {
+    patches: ImmerPatch[];
+    inversePatches: ImmerPatch[];
+    status: 'pending' | 'committed' | 'aborted';
+    abort(): void;
+    commit(): void;
+};
 /**
  * Эте не ссылка в "классическом" понимании, а абстракция
  * для работы с элементом кеша ресурса.
@@ -82,9 +93,13 @@ export type ResourceRefInstanse<D extends ResourceDefinition> = {
         unlock: () => void;
     };
     unlockOne(): void;
+    /**
+     * @deprecated
+     */
     update(updateFn: (data: D['Data']) => D['Data']): {
         rollback: () => void;
     };
+    patch(patchFn: (data: D['Data']) => void): ResourceTransaction | null;
     invalidate(): void;
     create(data: D['Data']): void;
 };

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

@@ -0,0 +1,3 @@
+export * from './Operation.types';
+export * from './Resource.types';
+export * from './shared.types';

package/dist/query/types/index.js

@@ -0,0 +1,3 @@
+export * from './Operation.types';
+export * from './Resource.types';
+export * from './shared.types';

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

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

package/dist/signals/base/Batcher.js

@@ -0,0 +1,55 @@
+const Scheduled = {
+    map: new Map(),
+    lowestRang: -1,
+    isLocked: false,
+    set(rang, fn) {
+        if (rang < this.lowestRang)
+            this.lowestRang = rang;
+        if (!this.map.has(rang)) {
+            this.map.set(rang, new Set());
+        }
+        this.map.get(rang).add(fn);
+    },
+    done() {
+        this.lowestRang = -1;
+        this.map.clear();
+    },
+    handleInfinity() {
+        const fns = this.map.get(Infinity);
+        this.map.delete(Infinity);
+        fns?.forEach((fn) => fn());
+        this.done();
+    },
+    run() {
+        if (this.map.size === 1 && this.map.has(Infinity))
+            return this.handleInfinity();
+        if (this.map.size === 0)
+            return this.done();
+        const iterationRang = this.lowestRang;
+        this.lowestRang += 1;
+        const fns = this.map.get(iterationRang);
+        this.map.delete(iterationRang);
+        fns?.forEach((fn) => fn());
+        this.run();
+    },
+};
+export const Batcher = {
+    scheduler(rang) {
+        return {
+            schedule: (fn) => {
+                if (!Scheduled.isLocked)
+                    return fn();
+                Scheduled.set(rang, fn);
+            }
+        };
+    },
+    batch(fn) {
+        if (Scheduled.isLocked)
+            return fn();
+        Scheduled.isLocked = true;
+        const v = fn();
+        Scheduled.run();
+        Scheduled.isLocked = false;
+        return v;
+    },
+};

package/dist/{signal → signals}/base/Computed.d.ts

@@ -1,10 +1,13 @@
 import { SubscriptionLike } from "rxjs";
-import { ReadableSignalLike } from "../../signal/base/types";
+import { ReadableSignalLike } from "./types";
 import { Signal } from "./Signal";
 export declare class Computed<T> extends Signal<T> implements SubscriptionLike, ReadableSignalLike<T> {
     private static _EMPTY;
     private _effect;
-    constructor(computeFn: () => T, doLog?: boolean);
+    constructor(computeFn: () => T, options?: {
+        disableDevtools?: boolean;
+        devtoolsName?: string;
+    });
     unsubscribe(): void;
     complete(): void;
 }

package/dist/{signal → signals}/base/Computed.js

@@ -3,16 +3,20 @@ import { Effect } from "./Effect";
 export class Computed extends Signal {
     static _EMPTY = Symbol('empty');
     _effect;
-    constructor(computeFn, doLog = false) {
+    constructor(computeFn, options) {
         let initialValue = Computed._EMPTY;
         const effect = new Effect(() => {
             if (initialValue === Computed._EMPTY) {
                 initialValue = computeFn();
                 return;
             }
+            this._rang = effect._rang;
             this.value = computeFn();
-        }, doLog);
-        super(initialValue);
+        });
+        super(initialValue, {
+            devtoolsName: 'Computed',
+            ...options,
+        });
         this._effect = effect;
     }
     unsubscribe() {

package/dist/{signal → signals}/base/Effect.d.ts

@@ -1,9 +1,9 @@
 import { SubscriptionLike } from "rxjs";
 export declare class Effect implements SubscriptionLike {
-    private _doLog;
-    closed: boolean;
     private _subscriptions;
-    constructor(effectFn: (runInTrackedContext: (fn: () => void) => void) => void, _doLog?: boolean);
+    closed: boolean;
+    _rang: number;
+    constructor(effectFn: (ctx: (fn: () => void) => void) => void);
     /**
      * Выполняет функцию в tracked-контексте, подписываясь на Tracker.
      */

package/dist/signals/base/Effect.js

@@ -0,0 +1,51 @@
+import { Batcher } from "./Batcher";
+import { Tracker } from "./Tracker";
+export class Effect {
+    _subscriptions = [];
+    closed = false;
+    _rang = 0;
+    constructor(effectFn) {
+        this._runInTrackedContext(effectFn, false);
+    }
+    /**
+     * Выполняет функцию в tracked-контексте, подписываясь на Tracker.
+     */
+    _runInTrackedContext(effectFn, isAsyncRun = false) {
+        // Отписываемся от предыдущих подписок
+        if (!isAsyncRun) {
+            this._rang = 0;
+            this._subscriptions.forEach((sub) => sub.unsubscribe());
+            this._subscriptions = [];
+        }
+        let isTrackedContext = true;
+        // TODO подумать как организовать планировщик при асинхронном запуске
+        let scheduler;
+        const scheduledFn = () => {
+            this._runInTrackedContext(effectFn);
+        };
+        // Подписываемся на Tracker. Во время выполнения подпишемся на все tracked наблюдатели.
+        const trackerSub = Tracker.tracked$.subscribe((tracked) => {
+            if (!isTrackedContext)
+                return;
+            if (tracked.rang <= this._rang) {
+                this._rang = tracked.rang + 1;
+            }
+            this._subscriptions.push(tracked.obsv$.subscribe(() => {
+                if (isTrackedContext) {
+                    return;
+                }
+                scheduler.schedule(scheduledFn);
+            }));
+        });
+        effectFn((fn) => {
+            this._runInTrackedContext(fn, true);
+        });
+        trackerSub.unsubscribe();
+        isTrackedContext = false;
+        scheduler = Batcher.scheduler(this._rang);
+    }
+    unsubscribe() {
+        this.closed = true;
+        this._subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare const Indexer: {
+    currentIndex: number;
+    getIndex(): number;
+};

package/dist/signals/base/Indexer.js

@@ -0,0 +1,6 @@
+export const Indexer = {
+    currentIndex: 0,
+    getIndex() {
+        return this.currentIndex++;
+    }
+};

package/dist/{signal → signals}/base/ReadonlySignal.d.ts

@@ -1,7 +1,10 @@
 import { Observable, Subscriber, TeardownLogic } from "rxjs";
-import { SyncObservable } from "./SyncObservable";
 import type { ReadableSignalLike } from "./types";
+import { SyncObservable } from "./SyncObservable";
 export declare class ReadonlySignal<T> extends SyncObservable<T> implements ReadableSignalLike<T> {
+    protected rang: number;
+    private readonly _devtools;
+    private static _logIdIndex;
     constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
     get value(): T;
     peek(): T;

package/dist/signals/base/ReadonlySignal.js

@@ -0,0 +1,46 @@
+import { Subscriber } from "rxjs";
+import { SharedOptions } from "../../common/options/SharedOptions";
+import { SyncObservable } from "./SyncObservable";
+import { Tracker } from "./Tracker";
+export class ReadonlySignal extends SyncObservable {
+    rang = 0;
+    _devtools;
+    static _logIdIndex = 0;
+    constructor(subscribe) {
+        const stateDevtools = SharedOptions.DEVTOOLS?.state;
+        const originalSubscribe = subscribe;
+        if (stateDevtools && originalSubscribe) {
+            subscribe = (subscriber) => {
+                const wrappedSubscriber = new Subscriber({
+                    next: (value) => {
+                        this._devtools?.(value);
+                        subscriber.next(value);
+                    },
+                    error: (err) => subscriber.error(err),
+                    complete: () => subscriber.complete()
+                });
+                return originalSubscribe.call(this, wrappedSubscriber);
+            };
+        }
+        super(subscribe);
+        if (stateDevtools) {
+            const id = ReadonlySignal._logIdIndex++;
+            const key = `ReadonlySignal:i=${id}`;
+            const initialValue = this.peek();
+            this._devtools = stateDevtools(key, initialValue);
+        }
+    }
+    get value() {
+        Tracker.next(this.rang, this);
+        return super.value;
+    }
+    peek() {
+        return super.value;
+    }
+    /**
+     * @deprecated
+     */
+    get() {
+        return this.value;
+    }
+}

package/dist/{signal → signals}/base/Signal.d.ts

@@ -1,7 +1,13 @@
 import { BehaviorSubject, Observable } from "rxjs";
-import { type ReadableSignalLike, UnaryFunction } from "./types";
-export declare class Signal<T> extends BehaviorSubject<T> implements ReadableSignalLike<T> {
-    constructor(initialValue: T);
+import type { ReadableSignalLike, SignalLike, UnaryFunction } from "./types";
+type SignalOptions = {
+    disableDevtools?: boolean;
+    devtoolsName?: string;
+};
+export declare class Signal<T> extends BehaviorSubject<T> implements SignalLike<T> {
+    private readonly _devtools;
+    protected _rang: number;
+    constructor(initialValue: T, options?: SignalOptions);
     protected _onChange(value: T): void;
     get value(): T;
     set value(value: T);
@@ -11,6 +17,10 @@ export declare class Signal<T> extends BehaviorSubject<T> implements ReadableSig
      * @deprecated use `value` instead.
      */
     get(): T;
+    /**
+     * @deprecated use `peek()` instead.
+     */
+    getValue(): T;
     /**
      * @deprecated use `next(value)` instead.
      */
@@ -28,3 +38,4 @@ export declare class Signal<T> extends BehaviorSubject<T> implements ReadableSig
     pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>, E extends Observable<any>, F extends Observable<any>, G extends Observable<any>, H extends Observable<any>, I extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>, op8: UnaryFunction<G, H>, op9: UnaryFunction<H, I>, ...operations: UnaryFunction<Observable<any>, Observable<any>>[]): Observable<unknown>;
     asReadonly(): ReadableSignalLike<T>;
 }
+export {};

package/dist/{signal → signals}/base/Signal.js

@@ -1,14 +1,28 @@
 import { BehaviorSubject } from "rxjs";
+import { SharedOptions } from "../../common/options/SharedOptions";
+import { Batcher } from "./Batcher";
+import { Indexer } from "./Indexer";
 import { Tracker } from "./Tracker";
 export class Signal extends BehaviorSubject {
-    constructor(initialValue) {
+    _devtools;
+    _rang = 0;
+    constructor(initialValue, options) {
         super(initialValue);
+        const stateDevtools = SharedOptions.DEVTOOLS?.state;
+        if (stateDevtools && options?.disableDevtools !== true) {
+            const id = Indexer.getIndex();
+            const key = `${options?.devtoolsName || 'Signal'}:i=${id}`;
+            this._devtools = stateDevtools(key, initialValue);
+        }
     }
     _onChange(value) {
-        super.next(value);
+        Batcher.batch(() => {
+            this._devtools?.(value);
+            super.next(value);
+        });
     }
     get value() {
-        Tracker.next(this);
+        Tracker.next(this._rang, this);
         return super.value;
     }
     set value(value) {
@@ -26,6 +40,12 @@ export class Signal extends BehaviorSubject {
     get() {
         return this.value;
     }
+    /**
+     * @deprecated use `peek()` instead.
+     */
+    getValue() {
+        return super.getValue();
+    }
     /**
      * @deprecated use `next(value)` instead.
      */