@fozy-labs/rx-toolkit 0.4.3 → 0.4.4

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,8 +1,11 @@
 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);
     const 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.js

@@ -1,3 +1,4 @@
+import { PromiseResolver } from "../../../common/utils";
 import { SharedOptions } from "../../../common/options/SharedOptions";
 import { QueriesCache } from "../QueriesCache";
 import { OperationAgent } from "./OperationAgent";
@@ -50,7 +51,7 @@ class OperationQueryState {
 }
 export class Operation {
     _options;
-    _queriesCache = new QueriesCache('Operation');
+    _queriesCache = new QueriesCache(60_000, 'Operation');
     _links = [];
     constructor(_options) {
         this._options = _options;
@@ -104,9 +105,10 @@ export class Operation {
              */
             linksMeta.forEach(({ link, ref, state }) => {
                 if (link.update && ref.has) {
-                    ref.update((draft) => {
+                    // 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 }));
@@ -161,17 +163,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,9 @@
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export declare class QueriesCache<KEY, VALUE> {
+    private _cacheLifeTime;
     private _logname;
     private readonly _cache;
-    constructor(_logname?: string);
+    constructor(_cacheLifeTime?: number | false, _logname?: string);
     getQueryCache(args: KEY): ReactiveCache<VALUE> | undefined;
     createQueryCache(args: KEY, initialState: VALUE): ReactiveCache<VALUE>;
 }

package/dist/query/core/QueriesCache.js

@@ -1,11 +1,11 @@
-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 {
+    _cacheLifeTime;
     _logname;
     _cache = new IndirectMap();
-    constructor(_logname = 'query') {
+    constructor(_cacheLifeTime = 60_000, _logname = 'query') {
+        this._cacheLifeTime = _cacheLifeTime;
         this._logname = _logname;
     }
     getQueryCache(args) {
@@ -14,20 +14,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/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,7 +20,8 @@ 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;
     constructor(_options: ResourceCreateOptions<D>);
     createAgent: () => ResourceAgent<D>;
     createRef: (args: D["Args"]) => ResourceRefInstanse<D>;
@@ -33,12 +33,6 @@ export declare class Resource<D extends ResourceDefinition> implements ResourceI
     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,3 +1,4 @@
+import { PromiseResolver } from "../../../common/utils";
 import { SharedOptions } from "../../../common/options/SharedOptions";
 import { QueriesCache } from "../../../query/core/QueriesCache";
 import { ResourceAgent } from "./ResourceAgent";
@@ -90,11 +91,67 @@ 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 = new QueriesCache('Resource');
+    _queriesCache;
+    _hooks;
     constructor(_options) {
         this._options = _options;
+        this._hooks = new QueryHooks(_options);
+        this._queriesCache = new QueriesCache(_options.cacheLifetime, 'Resource');
     }
     createAgent = () => {
         return new ResourceAgent(this);
@@ -106,7 +163,18 @@ export class Resource {
         return this._queriesCache.getQueryCache(args);
     }
     createQueryCache(args) {
-        return this._queriesCache.createQueryCache(args, ResourceQueryState.create());
+        const cache = this._queriesCache.createQueryCache(args, ResourceQueryState.create());
+        const hookResolvers = this._hooks.onCacheEntryAdded(args);
+        const spySub = cache.spy$.subscribe((state) => {
+            if (!state.isDone)
+                return;
+            hookResolvers.cacheDataLoaded();
+            spySub.unsubscribe();
+        });
+        cache.onClean$.subscribe(() => {
+            hookResolvers.cacheEntryRemoved();
+        });
+        return cache;
     }
     incrementLock(args, options) {
         let cache = options?.cache ?? this.getQueryCache(args);
@@ -124,22 +192,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,23 +206,23 @@ 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);
-        }
-        else {
-            cache.next(state);
+            cache = this.createQueryCache(args);
         }
+        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) => {
             if (abortController.signal.aborted) {
                 return;
             }
+            hookResolvers.fulfilledSuccess(data);
             const selectedData = this._options.select ? this._options.select(data) : data;
             cache.next(ResourceQueryState.success(state, selectedData));
         })
@@ -178,7 +230,8 @@ export class Resource {
             if (abortController.signal.aborted) {
                 return;
             }
-            SharedOptions.onError?.(error);
+            hookResolvers.fulfilledError(error);
+            SharedOptions.onError?.(error); // TODO перенести в хуки
             cache.next(ResourceQueryState.error(state, 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/Resource.types.d.ts

@@ -13,6 +13,31 @@ 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?: (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;
+    }>;
 };
 /**
  * Определение типов ресурса
@@ -45,8 +70,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 +118,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/signals/base/Computed.js

@@ -20,8 +20,7 @@ export class Computed extends Signal {
         this._effect = effect;
     }
     unsubscribe() {
-        this._effect.unsubscribe();
-        super.unsubscribe();
+        this.complete();
     }
     complete() {
         this._effect.unsubscribe();

package/dist/signals/base/Effect.js

@@ -11,10 +11,10 @@ export class Effect {
      * Выполняет функцию в 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;
@@ -43,6 +43,7 @@ export class Effect {
         trackerSub.unsubscribe();
         isTrackedContext = false;
         scheduler = Batcher.scheduler(this._rang);
+        prevSubscriptions?.forEach((sub) => sub.unsubscribe());
     }
     unsubscribe() {
         this.closed = true;

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/package.json

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