@fozy-labs/rx-toolkit 0.4.4 → 0.4.5

package/dist/common/devtools/reduxDevtools.js

@@ -8,17 +8,28 @@ export function reduxDevtools(options = {}) {
     const reduxDevtools = devtools.connect({ name: options.name ?? 'RxToolkit' });
     reduxDevtools.init(state);
     const scheduler = Batcher.scheduler(Infinity);
+    let isCreated = false;
     const updateFn = () => {
-        reduxDevtools.send({ type: 'update' }, state);
+        reduxDevtools.send({ type: isCreated ? 'create' : 'update' }, state);
+        isCreated = false;
+    };
+    const clearFn = () => {
+        reduxDevtools.send({ type: 'clear' }, state);
     };
     const createFn = () => {
-        reduxDevtools.send({ type: 'create' }, state);
+        isCreated = true;
+        return updateFn;
     };
     return {
         state(name, initState) {
             state = { ...state, [name]: initState };
-            scheduler.schedule(createFn);
+            scheduler.schedule(createFn());
             return (newState) => {
+                if (newState === '$COMPLETE' || newState === '$CLEANED') {
+                    delete state[name];
+                    clearFn();
+                    return;
+                }
                 state = { ...state, [name]: newState };
                 scheduler.schedule(updateFn);
             };

package/dist/query/core/Opertation/Operation.d.ts

@@ -1,6 +1,5 @@
 import type { ReactiveCache } from "../../../query/lib/ReactiveCache";
 import type { FallbackOnNever, OperationCreateOptions, OperationDefinition, OperationInstance } from "../../../query/types";
-import { QueriesCache } from "../QueriesCache";
 import { OperationAgent } from "./OperationAgent";
 export type CoreOperationQueryState<D extends OperationDefinition> = {
     arg: D['Args'] | null;
@@ -15,16 +14,19 @@ export type CoreOperationQueryState<D extends OperationDefinition> = {
 };
 export declare class Operation<D extends OperationDefinition> implements OperationInstance<D> {
     private readonly _options;
-    readonly _queriesCache: QueriesCache<D["Args"], CoreOperationQueryState<D>>;
+    private _queriesCache;
+    private _hooks;
     private _links;
+    private _DEFAULT_CACHE_LIFETIME;
     constructor(_options: OperationCreateOptions<D>);
     private _createLinks;
     createAgent(): OperationAgent<D>;
     getQueryCache(args: D['Args']): ReactiveCache<CoreOperationQueryState<D>> | undefined;
-    createQueryCache(args: D['Args']): ReactiveCache<CoreOperationQueryState<D>>;
+    createQueryCache(args: D['Args'], state?: CoreOperationQueryState<D>): ReactiveCache<CoreOperationQueryState<D>>;
     initiate(args: D['Args'], options?: {
         cache?: ReactiveCache<CoreOperationQueryState<D>>;
     }): ReactiveCache<CoreOperationQueryState<D>>;
+    private _initiate;
     /**
      * Используеются для обртной совместимости, а надо ли менять что-то - хз
      * @deprecated

package/dist/query/core/Opertation/Operation.js

@@ -1,6 +1,7 @@
 import { PromiseResolver } from "../../../common/utils";
-import { SharedOptions } from "../../../common/options/SharedOptions";
+import { Batcher } from "../../../signals";
 import { QueriesCache } from "../QueriesCache";
+import { QueriesLifetimeHooks } from "../QueriesLifetimeHooks";
 import { OperationAgent } from "./OperationAgent";
 class OperationQueryState {
     static create() {
@@ -51,10 +52,14 @@ class OperationQueryState {
 }
 export class Operation {
     _options;
-    _queriesCache = new QueriesCache(60_000, 'Operation');
+    _queriesCache;
+    _hooks;
     _links = [];
+    _DEFAULT_CACHE_LIFETIME = 1_000;
     constructor(_options) {
         this._options = _options;
+        this._queriesCache = new QueriesCache(this._options.cacheLifetime ?? this._DEFAULT_CACHE_LIFETIME);
+        this._hooks = new QueriesLifetimeHooks(_options, 'Operation');
         this._createLinks();
     }
     _createLinks() {
@@ -68,14 +73,31 @@ export class Operation {
     getQueryCache(args) {
         return this._queriesCache.getQueryCache(args);
     }
-    createQueryCache(args) {
-        return this._queriesCache.createQueryCache(args, OperationQueryState.create());
+    createQueryCache(args, state = OperationQueryState.create()) {
+        const cache = this._queriesCache.createQueryCache(args, state);
+        const hookResolvers = this._hooks.onCacheEntryAdded(args);
+        const spySub = cache.spy$.subscribe((state) => {
+            if (!state.isDone)
+                return;
+            hookResolvers.cacheDataLoaded();
+            spySub.unsubscribe();
+        });
+        cache.spy$.subscribe((state) => {
+            hookResolvers.dataChanged$.next(state);
+        });
+        cache.onClean$.subscribe(() => {
+            hookResolvers.cacheEntryRemoved();
+        });
+        return cache;
     }
     initiate(args, options) {
-        let cache = options?.cache ?? this._queriesCache.getQueryCache(args);
+        return Batcher.batch(() => this._initiate(args, options));
+    }
+    _initiate(args, options) {
+        let cache = options?.cache ?? this.getQueryCache(args);
         const state = OperationQueryState.load(cache?.value, args);
         if (!cache) {
-            cache = this._queriesCache.createQueryCache(args, state);
+            cache = this.createQueryCache(args, state);
         }
         else {
             cache.next(state);
@@ -85,6 +107,8 @@ export class Operation {
             const ref = link.resource.createRef(forwardedArgs);
             return { link, ref, state: {} };
         });
+        const query = this._options.queryFn(args);
+        const hookResolvers = this._hooks.onQueryStarted(args);
         linksMeta.forEach(({ link, ref, state }) => {
             if (link.lock) {
                 state.unlocker = ref.lock();
@@ -95,43 +119,51 @@ export class Operation {
                 });
             }
         });
-        const query = this._options.queryFn(args);
         query
             .then((result) => {
-            const data = this._options.select ? this._options.select(result) : result;
-            cache.next(OperationQueryState.success(state, data));
-            /**
-             * Обновляем связанные ресурсы
-             */
-            linksMeta.forEach(({ link, ref, state }) => {
-                if (link.update && ref.has) {
-                    // TODO подумать, нужно ли добавлять обработку, если patch() -> null (и в принце про работу patch)
-                    ref.patch((draft) => {
-                        return link.update({ draft, args, data });
-                    })?.commit();
-                }
-                if (link.create && !ref.has) {
-                    ref.create(link.create({ args, data }));
-                }
-                state.patch?.commit();
+            Batcher.batch(() => {
+                const data = this._options.select ? this._options.select(result) : result;
+                cache.next(OperationQueryState.success(state, data));
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ link, ref, state }) => {
+                    if (link.update && ref.has) {
+                        // TODO подумать, нужно ли добавлять обработку, если patch() -> null (и в принце про работу patch)
+                        ref.patch((draft) => {
+                            return link.update({ draft, args, data });
+                        })?.commit();
+                    }
+                    if (link.create && !ref.has) {
+                        ref.create(link.create({ args, data }));
+                    }
+                    state.patch?.commit();
+                });
+                hookResolvers.fulfilledSuccess(data);
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ state }) => {
+                    state.unlocker?.unlock();
+                });
             });
         })
             .catch((error) => {
-            SharedOptions.onError?.(error);
-            cache.next(OperationQueryState.error(state, error));
-            /**
-             * Обновляем связанные ресурсы
-             */
-            linksMeta.forEach(({ state }) => {
-                state.patch?.abort();
-            });
-        })
-            .finally(() => {
-            /**
-             * Обновляем связанные ресурсы
-             */
-            linksMeta.forEach(({ state }) => {
-                state.unlocker?.unlock();
+            Batcher.batch(() => {
+                cache.next(OperationQueryState.error(state, error));
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ state }) => {
+                    state.patch?.abort();
+                });
+                hookResolvers.fulfilledError(error);
+                /**
+                 * Обновляем связанные ресурсы
+                 */
+                linksMeta.forEach(({ state }) => {
+                    state.unlocker?.unlock();
+                });
             });
         });
         return cache;

package/dist/query/core/QueriesCache.d.ts

@@ -1,9 +1,8 @@
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export declare class QueriesCache<KEY, VALUE> {
     private _cacheLifeTime;
-    private _logname;
     private readonly _cache;
-    constructor(_cacheLifeTime?: number | false, _logname?: string);
+    constructor(_cacheLifeTime?: number | false);
     getQueryCache(args: KEY): ReactiveCache<VALUE> | undefined;
     createQueryCache(args: KEY, initialState: VALUE): ReactiveCache<VALUE>;
 }

package/dist/query/core/QueriesCache.js

@@ -2,11 +2,9 @@ import { IndirectMap } from "../../query/lib/IndirectMap";
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export class QueriesCache {
     _cacheLifeTime;
-    _logname;
     _cache = new IndirectMap();
-    constructor(_cacheLifeTime = 60_000, _logname = 'query') {
+    constructor(_cacheLifeTime = 60_000) {
         this._cacheLifeTime = _cacheLifeTime;
-        this._logname = _logname;
     }
     getQueryCache(args) {
         return this._cache.get(args);

package/dist/query/core/QueriesLifetimeHooks.d.ts

@@ -0,0 +1,21 @@
+import { Subject } from "rxjs";
+import { OnCacheEntryAdded, OnQueryStarted } from "../../query/types";
+type Options<ARGS, DATA> = {
+    onCacheEntryAdded?: OnCacheEntryAdded<ARGS, DATA>;
+    onQueryStarted?: OnQueryStarted<ARGS, DATA>;
+};
+export declare class QueriesLifetimeHooks<ARGS, DATA> {
+    private onCacheEntryAddedListeners;
+    private onQueryStartedListeners;
+    constructor(options: Options<ARGS, DATA> | undefined, devtoolName: string | undefined);
+    onCacheEntryAdded: (args: ARGS) => {
+        cacheDataLoaded: () => void;
+        cacheEntryRemoved: () => void;
+        dataChanged$: Subject<DATA>;
+    };
+    onQueryStarted: (args: ARGS) => {
+        fulfilledSuccess: (data: DATA) => void;
+        fulfilledError: (error: unknown) => void;
+    };
+}
+export {};

package/dist/query/core/QueriesLifetimeHooks.js

@@ -0,0 +1,89 @@
+import { Subject } from "rxjs";
+import { SharedOptions } from "../../common/options/SharedOptions";
+import { PromiseResolver } from "../../common/utils";
+import { Indexer } from "../../signals/base/Indexer";
+export class QueriesLifetimeHooks {
+    onCacheEntryAddedListeners = [];
+    onQueryStartedListeners = [];
+    constructor(options, devtoolName) {
+        if (options?.onCacheEntryAdded) {
+            this.onCacheEntryAddedListeners.push(options.onCacheEntryAdded);
+        }
+        if (options?.onQueryStarted) {
+            this.onQueryStartedListeners.push(options.onQueryStarted);
+        }
+        if (devtoolName) {
+            const stateDevtools = SharedOptions.DEVTOOLS?.state;
+            if (stateDevtools) {
+                this.onCacheEntryAddedListeners.push(async (args, { $cacheEntryRemoved, dataChanged$ }) => {
+                    const key = `${devtoolName}:${JSON.stringify(args)}:i=${Indexer.getIndex()}`;
+                    let devtools = null;
+                    dataChanged$.subscribe((state) => {
+                        if (!devtools) {
+                            devtools = stateDevtools(key, state);
+                            return;
+                        }
+                        devtools(state);
+                    });
+                    $cacheEntryRemoved.then(() => {
+                        devtools('$CLEANED');
+                    });
+                });
+            }
+        }
+        if (SharedOptions.onError) {
+            this.onQueryStartedListeners.push(async (args, { $queryFulfilled }) => {
+                try {
+                    await $queryFulfilled;
+                }
+                catch (error) {
+                    SharedOptions.onError(error);
+                }
+            });
+        }
+    }
+    onCacheEntryAdded = (args) => {
+        const cacheDataLoadedResolver = new PromiseResolver();
+        const cacheEntryRemovedResolver = new PromiseResolver();
+        const dataChanged$ = new Subject(); // TODO не нравится мне это, мб передавать $spy в аргументы?
+        cacheEntryRemovedResolver.promise.finally(() => {
+            dataChanged$.complete();
+        });
+        this.onCacheEntryAddedListeners.forEach((listener) => {
+            listener(args, {
+                $cacheDataLoaded: cacheDataLoadedResolver.promise,
+                $cacheEntryRemoved: cacheEntryRemovedResolver.promise,
+                dataChanged$,
+            });
+        });
+        return {
+            cacheDataLoaded: () => cacheDataLoadedResolver.resolve(),
+            cacheEntryRemoved: () => cacheEntryRemovedResolver.resolve(),
+            dataChanged$,
+        };
+    };
+    onQueryStarted = (args) => {
+        const queryFulfilledResolver = new PromiseResolver();
+        this.onQueryStartedListeners.forEach((listener) => {
+            listener(args, {
+                $queryFulfilled: queryFulfilledResolver.promise
+            });
+        });
+        return {
+            fulfilledSuccess: (data) => {
+                queryFulfilledResolver.resolve({
+                    data,
+                    error: undefined,
+                    isError: false
+                });
+            },
+            fulfilledError: (error) => {
+                queryFulfilledResolver.resolve({
+                    data: undefined,
+                    error,
+                    isError: true
+                });
+            }
+        };
+    };
+}

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

@@ -22,11 +22,12 @@ export declare class Resource<D extends ResourceDefinition> implements ResourceI
     private readonly _options;
     private readonly _queriesCache;
     private readonly _hooks;
+    private _DEFAULT_CACHE_LIFETIME;
     constructor(_options: ResourceCreateOptions<D>);
     createAgent: () => ResourceAgent<D>;
     createRef: (args: D["Args"]) => ResourceRefInstanse<D>;
     getQueryCache(args: D['Args']): CoreResourceQueryCache<D> | undefined;
-    createQueryCache(args: D['Args']): CoreResourceQueryCache<D>;
+    createQueryCache(args: D['Args'], state?: CoreResourceQueryState<D>): CoreResourceQueryCache<D>;
     incrementLock(args: D['Args'], options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D>;

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

@@ -1,6 +1,5 @@
-import { PromiseResolver } from "../../../common/utils";
-import { SharedOptions } from "../../../common/options/SharedOptions";
-import { QueriesCache } from "../../../query/core/QueriesCache";
+import { QueriesCache } from "../QueriesCache";
+import { QueriesLifetimeHooks } from "../QueriesLifetimeHooks";
 import { ResourceAgent } from "./ResourceAgent";
 import { ResourceRef } from "./ResourceRef";
 class ResourceQueryState {
@@ -91,67 +90,15 @@ class ResourceQueryState {
         };
     }
 }
-// TODO вынести и унифицировать; как-то организовать глобальные хуки и devtools через хуки
-class QueryHooks {
-    _options;
-    onCacheEntryAddedListeners = [];
-    onQueryStartedListeners = [];
-    constructor(_options) {
-        this._options = _options;
-        if (_options?.onCacheEntryAdded) {
-            this.onCacheEntryAddedListeners.push(_options.onCacheEntryAdded);
-        }
-        if (_options?.onQueryStarted) {
-            this.onQueryStartedListeners.push(_options.onQueryStarted);
-        }
-    }
-    onCacheEntryAdded = (args) => {
-        const cacheDataLoadedResolver = new PromiseResolver();
-        const cacheEntryRemovedResolver = new PromiseResolver();
-        this.onCacheEntryAddedListeners.forEach((listener) => {
-            listener(args, {
-                $cacheDataLoaded: cacheDataLoadedResolver.promise,
-                $cacheEntryRemoved: cacheEntryRemovedResolver.promise,
-            });
-        });
-        return {
-            cacheDataLoaded: () => cacheDataLoadedResolver.resolve(),
-            cacheEntryRemoved: () => cacheEntryRemovedResolver.resolve(),
-        };
-    };
-    onQueryStarted = (args) => {
-        const queryFulfilledResolver = new PromiseResolver();
-        this.onQueryStartedListeners.forEach((listener) => {
-            listener(args, {
-                $queryFulfilled: queryFulfilledResolver.promise
-            });
-        });
-        return {
-            fulfilledSuccess: (data) => {
-                queryFulfilledResolver.resolve({
-                    data,
-                    error: undefined,
-                    isError: false
-                });
-            },
-            fulfilledError: (error) => {
-                queryFulfilledResolver.resolve({
-                    data: undefined,
-                    error,
-                    isError: true
-                });
-            }
-        };
-    };
-}
 export class Resource {
     _options;
     _queriesCache;
     _hooks;
+    _DEFAULT_CACHE_LIFETIME = 60_000;
     constructor(_options) {
         this._options = _options;
-        this._hooks = new QueryHooks(_options);
-        this._queriesCache = new QueriesCache(_options.cacheLifetime, 'Resource');
+        this._hooks = new QueriesLifetimeHooks(_options, 'Resource');
+        this._queriesCache = new QueriesCache(_options.cacheLifetime ?? this._DEFAULT_CACHE_LIFETIME);
     }
     createAgent = () => {
         return new ResourceAgent(this);
@@ -162,8 +109,8 @@ export class Resource {
     getQueryCache(args) {
         return this._queriesCache.getQueryCache(args);
     }
-    createQueryCache(args) {
-        const cache = this._queriesCache.createQueryCache(args, ResourceQueryState.create());
+    createQueryCache(args, state = ResourceQueryState.create()) {
+        const cache = this._queriesCache.createQueryCache(args, state);
         const hookResolvers = this._hooks.onCacheEntryAdded(args);
         const spySub = cache.spy$.subscribe((state) => {
             if (!state.isDone)
@@ -171,6 +118,9 @@ export class Resource {
             hookResolvers.cacheDataLoaded();
             spySub.unsubscribe();
         });
+        cache.spy$.subscribe((data) => {
+            hookResolvers.dataChanged$.next(data);
+        });
         cache.onClean$.subscribe(() => {
             hookResolvers.cacheEntryRemoved();
         });
@@ -209,30 +159,31 @@ export class Resource {
         let cache = options?.cache ?? this.getQueryCache(args);
         const state = ResourceQueryState.load(cache?.value, args);
         if (!cache) {
-            cache = this.createQueryCache(args);
+            cache = this.createQueryCache(args, state);
+        }
+        else {
+            cache.next(state);
         }
-        cache.next(state);
         let abortController = state.abortController;
         abortController?.abort();
         abortController = new AbortController();
         const query = this._options.queryFn(args, { abortSignal: abortController.signal });
         const hookResolvers = this._hooks.onQueryStarted(args);
         query
-            .then((data) => {
+            .then((result) => {
             if (abortController.signal.aborted) {
                 return;
             }
+            const data = this._options.select ? result._options.select(result) : result;
+            cache.next(ResourceQueryState.success(state, data));
             hookResolvers.fulfilledSuccess(data);
-            const selectedData = this._options.select ? this._options.select(data) : data;
-            cache.next(ResourceQueryState.success(state, selectedData));
         })
             .catch((error) => {
             if (abortController.signal.aborted) {
                 return;
             }
-            hookResolvers.fulfilledError(error);
-            SharedOptions.onError?.(error); // TODO перенести в хуки
             cache.next(ResourceQueryState.error(state, error));
+            hookResolvers.fulfilledError(error);
         });
         return cache;
     }

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

@@ -1,5 +1,5 @@
 import { ReadableSignalLike } from "../../signals";
-import { FallbackOnNever } from "./shared.types";
+import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
 import { ResourceDefinition, ResourceInstance } from "./Resource.types";
 /**
  * Функция создания операции
@@ -15,6 +15,24 @@ export type OperationCreateOptions<D extends OperationDefinition> = {
     queryFn: (args: D["Args"]) => Promise<D["Result"]>;
     /** Связанные ресурсы */
     link?: (link: <RD extends ResourceDefinition>(options: LinkOptions<D, RD>) => void) => void;
+    /**
+     * Время жизни кеша в миллисекундах. По умолчанию 1_000 (1 секунда).
+     * Если указано false - кеш не удаляется автоматически.
+     */
+    cacheLifetime?: number | false;
+    /**
+     * Хук, вызываемый при добавлении нового элемента в кеш.
+     * Также позволяет отследить:
+     *  - когда данные были загружены (впервые)
+     *  - когда элемент был удален из кеша
+     */
+    onCacheEntryAdded?: OnCacheEntryAdded<D["Args"], D["Data"]>;
+    /**
+     * Хук, вызываемый при старте запроса.
+     * Также позволяет отследить:
+     * - завершение запроса с результатом или ошибкой
+     */
+    onQueryStarted?: OnQueryStarted<D["Args"], D["Result"]>;
 };
 /**
  * Настройки связи операции с ресурсом

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

@@ -1,6 +1,6 @@
 import { Patch as ImmerPatch } from "immer";
 import { ReadableSignalLike } from "../../signals";
-import { FallbackOnNever } from "./shared.types";
+import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
 /**
  * Функция создания ресурса
  */
@@ -18,26 +18,19 @@ export type ResourceCreateOptions<D extends ResourceDefinition> = {
      * Если указано false - кеш не удаляется автоматически.
      */
     cacheLifetime?: number | false;
-    onCacheEntryAdded?: (args: D["Args"], tools: CacheEntryAddedTools<D>) => void;
-    onQueryStarted?: (args: D["Args"], tools: QueryStartedTools<D>) => void;
-};
-export type CacheEntryAddedTools<D extends ResourceDefinition> = {
-    /** Функция для ожидания загрузки данных в кеш */
-    $cacheDataLoaded: Promise<void>;
-    /** Функция для ожидания удаления кеша */
-    $cacheEntryRemoved: Promise<void>;
-};
-export type QueryStartedTools<D extends ResourceDefinition> = {
-    /** Функция для уведомления об успешном завершении запроса */
-    $queryFulfilled: Promise<{
-        data: D["Result"];
-        error: undefined;
-        isError: false;
-    } | {
-        data: undefined;
-        error: unknown;
-        isError: true;
-    }>;
+    /**
+     * Хук, вызываемый при добавлении нового элемента в кеш.
+     * Также позволяет отследить:
+     *  - когда данные были загружены (впервые)
+     *  - когда элемент был удален из кеша
+     */
+    onCacheEntryAdded?: OnCacheEntryAdded<D["Args"], D["Data"]>;
+    /**
+     * Хук, вызываемый при старте запроса.
+     * Также позволяет отследить:
+     * - завершение запроса с результатом или ошибкой
+     */
+    onQueryStarted?: OnQueryStarted<D["Args"], D["Result"]>;
 };
 /**
  * Определение типов ресурса

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

@@ -1,4 +1,26 @@
+import { Subject } from "rxjs";
 export type Prettify<T> = {
     [KeyType in keyof T]: T[KeyType];
 } & {};
 export type FallbackOnNever<T, F> = [T] extends [never] ? F : T;
+export type CacheEntryAddedTools<DATA> = {
+    /** Функция для ожидания загрузки данных в кеш */
+    $cacheDataLoaded: Promise<void>;
+    /** Функция для ожидания удаления кеша */
+    $cacheEntryRemoved: Promise<void>;
+    dataChanged$: Subject<DATA>;
+};
+export type QueryStartedTools<DATA> = {
+    /** Функция для уведомления об успешном завершении запроса */
+    $queryFulfilled: Promise<{
+        data: DATA;
+        error: undefined;
+        isError: false;
+    } | {
+        data: undefined;
+        error: unknown;
+        isError: true;
+    }>;
+};
+export type OnCacheEntryAdded<ARGS, DATA> = (args: ARGS, tools: CacheEntryAddedTools<DATA>) => void;
+export type OnQueryStarted<ARGS, DATA> = (args: ARGS, tools: QueryStartedTools<DATA>) => void;

package/dist/signals/base/Computed.js

@@ -12,6 +12,8 @@ export class Computed extends Signal {
             }
             this._rang = effect._rang;
             this.value = computeFn();
+        }, () => {
+            this.complete();
         });
         super(initialValue, {
             devtoolsName: 'Computed',
@@ -23,6 +25,8 @@ export class Computed extends Signal {
         this.complete();
     }
     complete() {
+        if (this.closed)
+            return;
         this._effect.unsubscribe();
         super.complete();
     }

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

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

package/dist/signals/base/Effect.js

@@ -1,10 +1,12 @@
 import { Batcher } from "./Batcher";
 import { Tracker } from "./Tracker";
 export class Effect {
+    _onComplete;
     _subscriptions = [];
     closed = false;
     _rang = 0;
-    constructor(effectFn) {
+    constructor(effectFn, _onComplete) {
+        this._onComplete = _onComplete;
         this._runInTrackedContext(effectFn, false);
     }
     /**
@@ -24,18 +26,27 @@ export class Effect {
             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) {
+        const trackerSub = Tracker.tracked$.subscribe({
+            next: (tracked) => {
+                if (!isTrackedContext)
                     return;
+                if (tracked.rang <= this._rang) {
+                    this._rang = tracked.rang + 1;
                 }
-                scheduler.schedule(scheduledFn);
-            }));
+                this._subscriptions.push(tracked.obsv$.subscribe(() => {
+                    if (isTrackedContext) {
+                        return;
+                    }
+                    scheduler.schedule(scheduledFn);
+                }));
+            },
+            complete: () => {
+                this.unsubscribe();
+            },
+            error: (err) => {
+                console.error(err);
+                this.unsubscribe();
+            },
         });
         effectFn((fn) => {
             this._runInTrackedContext(fn, true);
@@ -46,7 +57,13 @@ export class Effect {
         prevSubscriptions?.forEach((sub) => sub.unsubscribe());
     }
     unsubscribe() {
+        this.complete();
+    }
+    complete() {
+        if (this.closed)
+            return;
         this.closed = true;
         this._subscriptions.forEach((sub) => sub.unsubscribe());
+        this._onComplete?.();
     }
 }

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

@@ -25,6 +25,7 @@ export declare class Signal<T> extends BehaviorSubject<T> implements SignalLike<
      * @deprecated use `next(value)` instead.
      */
     set(value: T): void;
+    complete(): void;
     pipe(): Signal<T>;
     pipe<A extends Observable<any>>(op1: UnaryFunction<ReadableSignalLike<T>, A>): A;
     pipe<A extends Observable<any>, B extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>): B;

package/dist/signals/base/Signal.js

@@ -52,6 +52,10 @@ export class Signal extends BehaviorSubject {
     set(value) {
         return this.next(value);
     }
+    complete() {
+        this._devtools?.('$COMPLETE');
+        super.complete();
+    }
     pipe(...operations) {
         return operations.reduce(pipeReducer, this);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fozy-labs/rx-toolkit",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",