@fozy-labs/rx-toolkit 0.4.3 → 0.4.5

package/dist/common/devtools/reduxDevtools.d.ts

@@ -1,2 +1,16 @@
 import { DevtoolsLike } from "./types";
-export declare function reduxDevtools(): DevtoolsLike;
+interface ReduxDevtoolsExtension {
+    connect(options: {
+        name: string;
+    }): ReduxDevtoolsConnection;
+}
+interface ReduxDevtoolsConnection {
+    init(state: any): void;
+    send(action: any, state: any): void;
+}
+type Options = {
+    name?: string;
+    driver?: ReduxDevtoolsExtension;
+};
+export declare function reduxDevtools(options?: Options): DevtoolsLike;
+export {};

package/dist/common/devtools/reduxDevtools.js

@@ -1,21 +1,35 @@
 import { Batcher } from "../../signals";
-export function reduxDevtools() {
+export function reduxDevtools(options = {}) {
+    const devtools = options.driver ?? window.__REDUX_DEVTOOLS_EXTENSION__;
+    if (!devtools) {
+        throw new Error('Redux Devtools extension is not installed');
+    }
     let state = {};
-    // @ts-ignore
-    const reduxDevtools = window.__REDUX_DEVTOOLS_EXTENSION__.connect({ name: 'RxToolkit' });
+    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/common/utils/PromiseResolver.d.ts

@@ -0,0 +1,7 @@
+export declare class PromiseResolver<T> {
+    private _resolve;
+    private _reject;
+    promise: Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: any): void;
+}

package/dist/common/utils/PromiseResolver.js

@@ -0,0 +1,14 @@
+export class PromiseResolver {
+    _resolve;
+    _reject;
+    promise = new Promise((resolve, reject) => {
+        this._resolve = resolve;
+        this._reject = reject;
+    });
+    resolve(value) {
+        this._resolve(value);
+    }
+    reject(reason) {
+        this._reject(reason);
+    }
+}

package/dist/common/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './PromiseResolver';

package/dist/common/utils/index.js

@@ -0,0 +1 @@
+export * from './PromiseResolver';

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,5 +1,7 @@
-import { SharedOptions } from "../../../common/options/SharedOptions";
+import { PromiseResolver } from "../../../common/utils";
+import { Batcher } from "../../../signals";
 import { QueriesCache } from "../QueriesCache";
+import { QueriesLifetimeHooks } from "../QueriesLifetimeHooks";
 import { OperationAgent } from "./OperationAgent";
 class OperationQueryState {
     static create() {
@@ -50,10 +52,14 @@ class OperationQueryState {
 }
 export class Operation {
     _options;
-    _queriesCache = new QueriesCache('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() {
@@ -67,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);
@@ -84,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();
@@ -94,42 +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) {
-                    ref.update((draft) => {
-                        return link.update({ draft, args, data });
-                    });
-                }
-                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;
@@ -161,17 +195,3 @@ export class Operation {
         return resolver.promise;
     }
 }
-class PromiseResolver {
-    _resolve;
-    _reject;
-    promise = new Promise((resolve, reject) => {
-        this._resolve = resolve;
-        this._reject = reject;
-    });
-    resolve(value) {
-        this._resolve(value);
-    }
-    reject(reason) {
-        this._reject(reason);
-    }
-}

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

@@ -6,7 +6,7 @@ export class OperationAgent {
     }, { disableDevtools: true });
     state$ = new Computed(() => {
         const operations = this._operations$.value;
-        const currState = operations.current$?.value;
+        const currState = operations.current$?.value$.value;
         // Нет текущего состояния — дефолт
         if (!currState) {
             return {

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

@@ -1,8 +1,8 @@
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export declare class QueriesCache<KEY, VALUE> {
-    private _logname;
+    private _cacheLifeTime;
     private readonly _cache;
-    constructor(_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

@@ -1,12 +1,10 @@
-import { SharedOptions } from "../../common/options/SharedOptions";
-import { Indexer } from "../../signals/base/Indexer";
 import { IndirectMap } from "../../query/lib/IndirectMap";
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export class QueriesCache {
-    _logname;
+    _cacheLifeTime;
     _cache = new IndirectMap();
-    constructor(_logname = 'query') {
-        this._logname = _logname;
+    constructor(_cacheLifeTime = 60_000) {
+        this._cacheLifeTime = _cacheLifeTime;
     }
     getQueryCache(args) {
         return this._cache.get(args);
@@ -14,20 +12,23 @@ export class QueriesCache {
     createQueryCache(args, initialState) {
         const cache = new ReactiveCache({
             initialState,
+            cacheLifeTime: this._cacheLifeTime,
         });
-        const stateDevtools = SharedOptions.DEVTOOLS?.state;
-        if (stateDevtools) {
-            const key = `${this._logname}:${JSON.stringify(args)}:i=${Indexer.getIndex()}`;
-            let devtools = stateDevtools(key, initialState);
-            cache.spy$.subscribe((state) => {
-                if (state === initialState)
-                    return;
-                devtools(state);
-            });
-            cache.onClean$.subscribe(() => {
-                devtools('$CLEANED');
-            });
-        }
+        // const stateDevtools = SharedOptions.DEVTOOLS?.state;
+        //
+        // if (stateDevtools) {
+        //     const key = `${this._logname}:${JSON.stringify(args)}:i=${Indexer.getIndex()}`;
+        //     let devtools = stateDevtools(key, initialState);
+        //
+        //     cache.spy$.subscribe((state) => {
+        //         if (state === initialState) return;
+        //         devtools(state);
+        //     });
+        //
+        //     cache.onClean$.subscribe(() => {
+        //         devtools('$CLEANED' as any);
+        //     });
+        // }
         cache.onClean$.subscribe(() => {
             this._cache.delete(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

@@ -1,6 +1,5 @@
 import { ReactiveCache } from "../../../query/lib/ReactiveCache";
 import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "../../../query/types";
-import { QueriesCache } from "../../../query/core/QueriesCache";
 import { ResourceAgent } from "./ResourceAgent";
 export type CoreResourceQueryState<D extends ResourceDefinition> = {
     transactions: ResourceTransaction[] | null;
@@ -21,24 +20,20 @@ export type CoreResourceQueryState<D extends ResourceDefinition> = {
 export type CoreResourceQueryCache<D extends ResourceDefinition> = ReactiveCache<CoreResourceQueryState<D>>;
 export declare class Resource<D extends ResourceDefinition> implements ResourceInstance<D> {
     private readonly _options;
-    readonly _queriesCache: QueriesCache<D["Args"], CoreResourceQueryState<D>>;
+    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>;
     decrementLock(args: D['Args'], options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D> | null;
-    /**
-     * @deprecated
-     */
-    updateData_legacy(args: D['Args'], updateFn: (data: D['Data']) => D['Data'], options?: {
-        cache?: CoreResourceQueryCache<D>;
-    }): CoreResourceQueryCache<D> | null;
     update(args: D['Args'], updateFn: (data: D['Data'], savedData: D['Data'] | null, transactions: ResourceTransaction[] | null) => {
         data: D['Data'];
         transactions: ResourceTransaction[] | null;

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

@@ -1,5 +1,5 @@
-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 {
@@ -92,9 +92,13 @@ class ResourceQueryState {
 }
 export class Resource {
     _options;
-    _queriesCache = new QueriesCache('Resource');
+    _queriesCache;
+    _hooks;
+    _DEFAULT_CACHE_LIFETIME = 60_000;
     constructor(_options) {
         this._options = _options;
+        this._hooks = new QueriesLifetimeHooks(_options, 'Resource');
+        this._queriesCache = new QueriesCache(_options.cacheLifetime ?? this._DEFAULT_CACHE_LIFETIME);
     }
     createAgent = () => {
         return new ResourceAgent(this);
@@ -105,8 +109,22 @@ export class Resource {
     getQueryCache(args) {
         return this._queriesCache.getQueryCache(args);
     }
-    createQueryCache(args) {
-        return 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)
+                return;
+            hookResolvers.cacheDataLoaded();
+            spySub.unsubscribe();
+        });
+        cache.spy$.subscribe((data) => {
+            hookResolvers.dataChanged$.next(data);
+        });
+        cache.onClean$.subscribe(() => {
+            hookResolvers.cacheEntryRemoved();
+        });
+        return cache;
     }
     incrementLock(args, options) {
         let cache = options?.cache ?? this.getQueryCache(args);
@@ -124,22 +142,6 @@ export class Resource {
         cache.next(ResourceQueryState.decrementLock(cache.value));
         return cache;
     }
-    /**
-     * @deprecated
-     */
-    updateData_legacy(args, updateFn, options) {
-        let cache = options?.cache ?? this.getQueryCache(args);
-        if (!cache) {
-            return null;
-        }
-        const cacheValue = cache.value;
-        if (!cacheValue.isDone) {
-            return cache;
-        }
-        const newData = updateFn(cacheValue.data);
-        cache.next(ResourceQueryState.setData(cache.value, newData));
-        return cache;
-    }
     update(args, updateFn, options) {
         let cache = options?.cache ?? this.getQueryCache(args);
         if (!cache) {
@@ -154,10 +156,10 @@ export class Resource {
         return cache;
     }
     initiate(args, options) {
-        let cache = options?.cache ?? this._queriesCache.getQueryCache(args);
+        let cache = options?.cache ?? this.getQueryCache(args);
         const state = ResourceQueryState.load(cache?.value, args);
         if (!cache) {
-            cache = this._queriesCache.createQueryCache(args, state);
+            cache = this.createQueryCache(args, state);
         }
         else {
             cache.next(state);
@@ -166,20 +168,22 @@ export class Resource {
         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 selectedData = this._options.select ? this._options.select(data) : data;
-            cache.next(ResourceQueryState.success(state, selectedData));
+            const data = this._options.select ? result._options.select(result) : result;
+            cache.next(ResourceQueryState.success(state, data));
+            hookResolvers.fulfilledSuccess(data);
         })
             .catch((error) => {
             if (abortController.signal.aborted) {
                 return;
             }
-            SharedOptions.onError?.(error);
             cache.next(ResourceQueryState.error(state, error));
+            hookResolvers.fulfilledError(error);
         });
         return cache;
     }

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

@@ -30,5 +30,5 @@ export declare class ResourceAgent<D extends ResourceDefinition> implements Reso
     constructor(_resource: Resource<D>);
     private _next;
     initiate(args: D["Args"], force?: boolean): void;
-    createAgent: () => ResourceAgentInstance<D>;
+    complete(): void;
 }

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

@@ -8,7 +8,7 @@ export class ResourceAgent {
     state$ = new Computed(() => {
         const resources = this._resources$.value;
         let prevState;
-        const currState = resources.current$?.value;
+        const currState = resources.current$?.value$.value;
         if (!currState?.isDone) {
             prevState = resources.previous$?.value;
         }
@@ -81,7 +81,8 @@ export class ResourceAgent {
             this._next(cache);
         }
     }
-    createAgent = () => {
-        return this;
-    };
+    complete() {
+        this.state$.complete();
+        this._resources$.complete();
+    }
 }

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

@@ -10,9 +10,6 @@ export declare class ResourceRef<D extends ResourceDefinition> implements Resour
         unlock: () => void;
     };
     unlockOne(): void;
-    update(updateFn: (data: D["Data"]) => D["Data"]): {
-        rollback: () => void;
-    };
     patch(patchFn: (data: D["Data"]) => void): ResourceTransaction | null;
     create(data: D["Data"]): void;
     invalidate(): void;

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

@@ -29,22 +29,6 @@ export class ResourceRef {
     unlockOne() {
         this._cacheItem = this._resource.decrementLock(this._args, { cache: this._cacheItem });
     }
-    update(updateFn) {
-        const cacheItem = this._cacheItem ?? this._resource.getQueryCache(this._args);
-        if (!cacheItem) {
-            console.warn('Trying to update non-existing cache item');
-            return {
-                rollback: () => { }
-            };
-        }
-        const value = cacheItem.value;
-        this._resource.updateData_legacy(this._args, updateFn, { cache: cacheItem });
-        return {
-            rollback: () => {
-                this._resource.updateData_legacy(this._args, () => value.data, { cache: cacheItem });
-            }
-        };
-    }
     patch(patchFn) {
         let isSkipped = true;
         const reapplyFn = (data, savedData, transactions) => {
@@ -56,12 +40,14 @@ export class ResourceRef {
             // Все pending - применяем и оставляем в очереди
             // Все commited (которые после pending) - применяем, но оставляем в очереди
             // Все aborted (которые после pending) - откатываем, но оставляем в очереди
+            // Если после aborted нет pending - пропускаем и убираем из очереди
             // Те после применения всех транзакций, очередь должна начинаться с первой pending транзакции (если есть), включая все, что после неё.
             let newSavedData = savedData ?? data;
             let currentData = savedData ?? data;
             const remainingTransactions = [];
             let foundPending = false;
-            transactions.forEach((transaction) => {
+            const lastPendingIndex = transactions.findLastIndex(t => t.status === 'pending');
+            transactions.forEach((transaction, index) => {
                 if (transaction.status === 'pending') {
                     foundPending = true;
                     // Применяем pending транзакцию и оставляем в очереди
@@ -76,9 +62,13 @@ export class ResourceRef {
                         remainingTransactions.push(transaction);
                     }
                     else if (transaction.status === 'aborted') {
-                        // Откатываем и оставляем в очереди
-                        currentData = applyPatches(currentData, transaction.inversePatches);
-                        remainingTransactions.push(transaction);
+                        // Проверяем, есть ли pending после текущей aborted
+                        const hasPendingAfter = index < lastPendingIndex;
+                        if (hasPendingAfter) {
+                            currentData = applyPatches(currentData, transaction.inversePatches);
+                            remainingTransactions.push(transaction);
+                        }
+                        // Если pending нет - пропускаем и убираем из очереди
                     }
                 }
                 else {

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

@@ -1,4 +1,5 @@
 import { Observable, Subject } from "rxjs";
+import { ReadableSignalLike } from "../../signals";
 type Options<VALUE> = {
     /**
      * Начальное состояние кэша
@@ -6,9 +7,11 @@ type Options<VALUE> = {
     initialState: VALUE;
     /**
      * Время жизни кэша в миллисекундах (пока нет подписок на кеш)
+     * Если указано `false`, кэш не будет очищаться автоматически.
+     * Если указано `0` или меньше, кэш будет очищаться сразу после отписки от него.
      * @default 60_000 (1 минута)
      */
-    cacheLifeTime?: number;
+    cacheLifeTime?: number | false;
 };
 /**
  * Класс `ReactiveCache` представляет собой реактивный кэш,
@@ -17,26 +20,15 @@ type Options<VALUE> = {
  * @template VALUE Тип значения, хранимого в кэше.
  */
 export declare class ReactiveCache<VALUE> {
-    /**
-     * Время жизни кэша в миллисекундах.
-     * Если значение больше 0, то кэш очищается через указанное время после отписки.
-     * @private
-     */
-    private readonly _cacheLifeTime;
     /**
      * Внутренний `BehaviorSubject`, хранящий текущее состояние кэша.
      * @private
      */
     private _state$;
-    /**
-     * Текущее значение.
-     * @private
-     */
-    private _value;
     /**
      * Реактивное значене (Observable)
      */
-    value$: Observable<VALUE>;
+    value$: ReadableSignalLike<VALUE>;
     /**
      * Значение без сайд-эффектов (для использования в DevTools)
      */
@@ -53,16 +45,8 @@ export declare class ReactiveCache<VALUE> {
      * @param options.cacheLifeTime Время жизни кэша в миллисекундах (по умолчанию 60_000).
      */
     constructor(options: Options<VALUE>);
-    /**
-     * Возвращает текущее значение кэша.
-     * @returns {VALUE} Текущее значение кэша.
-     */
+    private _getOnRefCountZero;
     get value(): VALUE;
-    /**
-     * Возвращает текущее значение кэша.
-     * @returns {VALUE} Текущее значение кэша.
-     */
-    peek(): VALUE;
     /**
      * Устанавливает новое значение в кэш и обновляет поток состояния.
      *

package/dist/query/lib/ReactiveCache.js

@@ -1,5 +1,5 @@
-import { finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
-import { Signal } from "../../signals";
+import { BehaviorSubject, finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
+import { signalize } from "../../signals";
 /**
  * Класс `ReactiveCache` представляет собой реактивный кэш,
  * который позволяет управлять состоянием и временем жизни кэшированных данных.
@@ -7,22 +7,11 @@ import { Signal } from "../../signals";
  * @template VALUE Тип значения, хранимого в кэше.
  */
 export class ReactiveCache {
-    /**
-     * Время жизни кэша в миллисекундах.
-     * Если значение больше 0, то кэш очищается через указанное время после отписки.
-     * @private
-     */
-    _cacheLifeTime;
     /**
      * Внутренний `BehaviorSubject`, хранящий текущее состояние кэша.
      * @private
      */
     _state$;
-    /**
-     * Текущее значение.
-     * @private
-     */
-    _value;
     /**
      * Реактивное значене (Observable)
      */
@@ -43,46 +32,37 @@ export class ReactiveCache {
      * @param options.cacheLifeTime Время жизни кэша в миллисекундах (по умолчанию 60_000).
      */
     constructor(options) {
-        this._cacheLifeTime = options.cacheLifeTime || 60_000;
-        this._state$ = new Signal(options.initialState, { disableDevtools: true });
-        this._value = options.initialState;
+        const cacheLifeTime = options.cacheLifeTime ?? 60_000;
+        this._state$ = new BehaviorSubject(options.initialState);
         this.spy$ = this._state$.pipe(takeUntil(this.onClean$));
-        this.value$ = this._state$.pipe(finalize(() => {
+        this.value$ = signalize(this._state$.pipe(finalize(() => {
             this.complete();
         }), share({
             connector: () => new ReplaySubject(1),
-            /**
-             * Если lifetime больше 0,
-             * то очистим кэш значения по истечении этого времени,
-             * иначе очищаем сразу после отписки.
-             */
-            resetOnRefCountZero: this._cacheLifeTime > 0
-                ? () => timer(this._cacheLifeTime)
-                : true,
+            resetOnRefCountZero: this._getOnRefCountZero(cacheLifeTime),
             resetOnComplete: true,
-        }));
+        })));
+    }
+    _getOnRefCountZero(cacheLifeTime) {
+        if (cacheLifeTime === false) {
+            return false;
+        }
+        if (cacheLifeTime <= 0) {
+            return true;
+        }
+        return () => {
+            return timer(cacheLifeTime);
+        };
     }
-    /**
-     * Возвращает текущее значение кэша.
-     * @returns {VALUE} Текущее значение кэша.
-     */
     get value() {
         return this._state$.value;
     }
-    /**
-     * Возвращает текущее значение кэша.
-     * @returns {VALUE} Текущее значение кэша.
-     */
-    peek() {
-        return this._value;
-    }
     /**
      * Устанавливает новое значение в кэш и обновляет поток состояния.
      *
      * @param value Новое значение для кэша.
      */
     next(value) {
-        this._value = value;
         this._state$.next(value);
     }
     /**
@@ -90,7 +70,7 @@ export class ReactiveCache {
      */
     complete() {
         this._state$.complete();
-        this.onClean$.next(this._value);
+        this.onClean$.next(this._state$.value);
         this.onClean$.complete();
     }
 }

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

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

package/dist/query/react/useResourceAgent.js

@@ -22,5 +22,8 @@ export function useResourceAgent(res, ...argss) {
         }
         agent.initiate(args);
     }, [args]);
+    React.useEffect(() => () => {
+        agent.complete();
+    }, []);
     return useSignal(agent.state$);
 }

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";
 /**
  * Функция создания ресурса
  */
@@ -13,6 +13,24 @@ export type ResourceCreateOptions<D extends ResourceDefinition> = {
     select?: (data: D["Result"]) => D["Selected"];
     /** Функция запроса данных */
     queryFn: (args: D["Args"], tools: ResourceQueryFnTools) => Promise<D["Result"]>;
+    /**
+     * Время жизни кеша в миллисекундах. По умолчанию 60_000 (1 минута).
+     * Если указано false - кеш не удаляется автоматически.
+     */
+    cacheLifetime?: number | false;
+    /**
+     * Хук, вызываемый при добавлении нового элемента в кеш.
+     * Также позволяет отследить:
+     *  - когда данные были загружены (впервые)
+     *  - когда элемент был удален из кеша
+     */
+    onCacheEntryAdded?: OnCacheEntryAdded<D["Args"], D["Data"]>;
+    /**
+     * Хук, вызываемый при старте запроса.
+     * Также позволяет отследить:
+     * - завершение запроса с результатом или ошибкой
+     */
+    onQueryStarted?: OnQueryStarted<D["Args"], D["Result"]>;
 };
 /**
  * Определение типов ресурса
@@ -45,8 +63,8 @@ export type ResourceAgentInstance<D extends ResourceDefinition> = {
     state$: ReadableSignalLike<ResourceQueryState<D>>;
     /** Инициирует запрос с указанными аргументами */
     initiate(args: D["Args"], force?: boolean): void;
-    /** Создает новый агент */
-    createAgent(): ResourceAgentInstance<D>;
+    /** Завершает работу агента, позволяя освободить ресурсы */
+    complete(): void;
 };
 /**
  * Состояние запроса ресурса
@@ -93,12 +111,6 @@ 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/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',
@@ -20,10 +22,11 @@ export class Computed extends Signal {
         this._effect = effect;
     }
     unsubscribe() {
-        this._effect.unsubscribe();
-        super.unsubscribe();
+        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,20 +1,22 @@
 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);
     }
     /**
      * Выполняет функцию в tracked-контексте, подписываясь на Tracker.
      */
     _runInTrackedContext(effectFn, isAsyncRun = false) {
-        // Отписываемся от предыдущих подписок
+        let prevSubscriptions;
         if (!isAsyncRun) {
             this._rang = 0;
-            this._subscriptions.forEach((sub) => sub.unsubscribe());
+            prevSubscriptions = this._subscriptions;
             this._subscriptions = [];
         }
         let isTrackedContext = true;
@@ -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);
@@ -43,9 +54,16 @@ export class Effect {
         trackerSub.unsubscribe();
         isTrackedContext = false;
         scheduler = Batcher.scheduler(this._rang);
+        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/ReadonlySignal.d.ts

@@ -3,8 +3,6 @@ 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

@@ -1,34 +1,9 @@
-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);

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.3",
+  "version": "0.4.5",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",