@fozy-labs/rx-toolkit 0.5.0-rc.3 → 0.5.0

package/README.md

@@ -46,7 +46,7 @@ RxToolkit решает эти проблемы, предоставляя сво
 // Описываем логику в обычном JavaScript
 const count$ = Signal.create(0);
 const doubled$ = Signal.compute(() => count$() * 2);
-const increment = () => count$.set(count$.peek() + 1);
+const increment = () => count$.set(count$() + 1);
 ```
 
 ###### Подключаем к фреймворку
@@ -81,7 +81,7 @@ const clicker$ = fromEvent(document, 'click').pipe(
 const clickCount$ = signalize(clicker$);
 const doubled$ = Signal.compute(() => clickCount$() * 2);
 
-console.log(doubled$.peek()); // Всегда актуальное значение
+console.log(doubled$()); // Всегда актуальное значение
 
 // Или наоборот, получаем событие из сигнала
 const on10click$ = doubled$.obs.pipe(

package/dist/query/api/createResourceDuplicator.d.ts

@@ -0,0 +1,4 @@
+import { DuplicatorOptions, ResourceDuplicator, DuplicatorDefinition } from "../../query/core/Resource/ResourceDuplicator";
+import { ResourceDefinition } from "../../query/types";
+export declare const createResourceDuplicator: <ARGS, RESULT, SELECTED = never>(options: DuplicatorOptions<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>) => ResourceDuplicator<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>;
+export type ResourceDuplicatorCreateFn<ARGS, RESULT, SELECTED = never> = (options: DuplicatorOptions<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>) => ResourceDuplicator<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>;

package/dist/query/api/createResourceDuplicator.js

@@ -0,0 +1,2 @@
+import { ResourceDuplicator } from "../../query/core/Resource/ResourceDuplicator";
+export const createResourceDuplicator = ((options) => new ResourceDuplicator(options));

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

@@ -1,10 +1,9 @@
 import { OperationAgentInstanse, OperationDefinition } from "../../../query/types";
-import { Computed } from "../../../signals";
 import type { Operation } from "./Operation";
 export declare class OperationAgent<D extends OperationDefinition> implements OperationAgentInstanse<D> {
     private _operation;
     private _operations$;
-    state$: Computed<{
+    state$: import("../../../signals/types").ComputeFn<{
         isLoading: boolean;
         isDone: boolean;
         isSuccess: boolean;

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

@@ -1,10 +1,10 @@
 import { Computed, Signal } from "../../../signals";
 export class OperationAgent {
     _operation;
-    _operations$ = new Signal({
+    _operations$ = Signal.create({
         current$: null,
     }, { isDisabled: true });
-    state$ = new Computed(() => {
+    state$ = Computed.create(() => {
         const operations = this._operations$.get();
         const currState = operations.current$?.value$.get();
         // Нет текущего состояния — дефолт

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

@@ -1,9 +1,8 @@
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
-import { shallowEqual } from "../../common/utils";
 export declare class QueriesCache<KEY, VALUE> {
     private _cacheLifeTime;
     private readonly _cache;
-    constructor(_cacheLifeTime?: number | false, compareArgsFn?: typeof shallowEqual);
+    constructor(_cacheLifeTime?: number | false, compareArgsFn?: ((a: KEY, b: KEY) => boolean));
     getQueryCache(args: KEY): ReactiveCache<VALUE> | undefined;
     createQueryCache(args: KEY, initialState: VALUE): ReactiveCache<VALUE>;
     values(): MapIterator<ReactiveCache<VALUE>>;

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

@@ -1,10 +1,9 @@
-import { Computed } from "../../../signals";
-import { ResourceAgentInstance, ResourceDefinition, ResourceQueryState } from "../../../query/types";
+import { ResourceAgentInstance, ResourceDefinition } from "../../../query/types";
 import type { Resource } from "./Resource";
 export declare class ResourceAgent<D extends ResourceDefinition> implements ResourceAgentInstance<D> {
     private _resource;
     private _resources$;
-    state$: Computed<{
+    state$: import("../../../signals/types").ComputeFn<{
         isInitiated: boolean;
         isLoading: boolean;
         isInitialLoading: boolean;
@@ -30,7 +29,6 @@ export declare class ResourceAgent<D extends ResourceDefinition> implements Reso
         args: NonNullable<D["Args"]> | undefined;
     }>;
     constructor(_resource: Resource<D>);
-    getState(values: D["Args"]): ResourceQueryState<D>;
     initiate(args: D["Args"], force?: boolean): void;
     compareArgs(args: D["Args"], otherArgs: D["Args"]): boolean;
     private _next;

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

@@ -1,11 +1,11 @@
 import { Computed, Signal } from "../../../signals";
 export class ResourceAgent {
     _resource;
-    _resources$ = new Signal({
+    _resources$ = Signal.create({
         previous$: null,
         current$: null,
     }, { isDisabled: true });
-    state$ = new Computed(() => {
+    state$ = Computed.create(() => {
         const resources = this._resources$.get();
         let prevState;
         const currState = resources.current$?.value$.get();
@@ -68,38 +68,6 @@ export class ResourceAgent {
     constructor(_resource) {
         this._resource = _resource;
     }
-    getState(values) {
-        const cache = this._resource.getQueryCache(values);
-        if (!cache) {
-            return {
-                isInitiated: false,
-                isLoading: false,
-                isInitialLoading: false,
-                isDone: false,
-                isSuccess: false,
-                isError: false,
-                isLocked: false,
-                isReloading: false,
-                error: undefined,
-                data: undefined,
-                args: undefined,
-            };
-        }
-        const state = cache.value;
-        return {
-            isInitiated: state.isInitiated,
-            isLoading: state.isLoading,
-            isInitialLoading: state.isLoading && !state.isDone,
-            isDone: state.isDone,
-            isSuccess: state.isSuccess,
-            isError: state.isError,
-            isLocked: state.isLocked,
-            isReloading: state.isReloading,
-            error: state.error ?? undefined,
-            data: state.data ?? undefined,
-            args: state.args ?? undefined,
-        };
-    }
     initiate(args, force = false) {
         const current = this._resources$.peek().current$;
         const cache = this._resource.getQueryCache(args);

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

@@ -0,0 +1,73 @@
+import { ResourceDefinition } from "../../../query/types";
+import { CoreResourceQueryState, Resource } from "./Resource";
+import { ReadableSignalLike } from "../../../signals/types";
+import { Observable, Subject } from "rxjs";
+import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
+export type DuplicatorOptions<D extends DuplicatorDefinition> = {
+    resource: Resource<D['RESOURCE_DEFINITION']>;
+    getArgKey: (item: D['ARGS_ITEM']) => string | number;
+    getDataKey: (item: D['DATA_ITEM']) => string | number;
+    cacheLifetime?: number | false;
+};
+export type DuplicatorDefinition<D extends ResourceDefinition = ResourceDefinition> = {
+    ARGS_ITEM: D['Args'] extends Array<any> ? D['Args'][number] : never;
+    DATA_ITEM: D['Data'] extends Array<any> ? D['Data'][number] : never;
+    RESOURCE_DEFINITION: D;
+};
+type State<D extends DuplicatorDefinition> = CoreResourceQueryState<D['RESOURCE_DEFINITION']> & {
+    unreleasedArgs?: D['ARGS_ITEM'][];
+};
+type Cache<D extends DuplicatorDefinition> = ComputedReactiveCache<State<D>>;
+export type CoreResourceDuplicatorCache<D extends DuplicatorDefinition> = Cache<D>;
+export declare class ResourceDuplicator<D extends DuplicatorDefinition> {
+    private _options;
+    private _fis;
+    private _caches;
+    private get _resource();
+    constructor(_options: DuplicatorOptions<D>);
+    getQueryCache(args: D['ARGS_ITEM'][]): Cache<D> | undefined;
+    createCache(args: D['ARGS_ITEM'][]): Cache<D>;
+    initiate(args: D['ARGS_ITEM'][], cache?: Cache<D>): Cache<D>;
+    serialize(args: D['ARGS_ITEM'][]): string;
+    compareArgs(a: D['ARGS_ITEM'][], b: D['ARGS_ITEM'][]): boolean;
+    createAgent: () => ResourceDuplicatorAgent<D>;
+    /** @deprecated */
+    d_init(args: D['ARGS_ITEM'][]): {
+        value$: import("../../../signals/types").ComputeFn<State<D>>;
+    };
+}
+export declare class ComputedReactiveCache<T> {
+    /**
+     * Реактивное значене (Observable)
+     */
+    value$: ReadableSignalLike<T>;
+    /**
+     * Значение без сайд-эффектов (для использования в DevTools)
+     */
+    spy$: Observable<T>;
+    /**
+     * Subject, уведомляющий об очистке кэша.
+     */
+    onClean$: Subject<T>;
+    closed: boolean;
+    private _getValue;
+    /**
+     * Создает новый экземпляр `ReactiveCacheItem`.
+     *
+     * @param options Параметры для настройки элемента кэша.
+     * @param options.initialState Начальное состояние кэша.
+     * @param options.cacheLifeTime Время жизни кэша в миллисекундах (по умолчанию 60_000).
+     */
+    constructor(options: {
+        obs: Observable<T>;
+        getValue: () => T;
+        cacheLifeTime: number | false;
+    });
+    private _getOnRefCountZero;
+    get value(): T;
+    /**
+     * Завершает работу кэша, закрывая все потоки и уведомляя об очистке.
+     */
+    complete(): void;
+}
+export {};

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

@@ -0,0 +1,227 @@
+import { Signal, signalize } from "../../../signals";
+import { finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
+import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
+export class ResourceDuplicator {
+    _options;
+    _fis = new Map();
+    _caches;
+    get _resource() {
+        return this._options.resource;
+    }
+    constructor(_options) {
+        this._options = _options;
+        this._caches = new Map();
+    }
+    getQueryCache(args) {
+        const key = this.serialize(args);
+        return this._caches.get(key);
+    }
+    createCache(args) {
+        const key = this.serialize(args);
+        const { value$ } = this.d_init(args);
+        const cache = new ComputedReactiveCache({
+            cacheLifeTime: this._options.cacheLifetime ?? 60_000,
+            getValue: () => value$.get(),
+            obs: value$.obs,
+        });
+        cache.onClean$.subscribe(() => {
+            args.forEach(arg => {
+                const argKey = this._options.getArgKey(arg);
+                const fi = this._fis.get(argKey);
+                if (!fi)
+                    return;
+                fi.k--;
+                if (fi.k <= 0) {
+                    this._fis.delete(argKey);
+                }
+            });
+            this._caches.delete(key);
+        });
+        this._caches.set(key, cache);
+        return cache;
+    }
+    initiate(args, cache) {
+        const cacheInstance = cache ?? this.getQueryCache(args) ?? this.createCache(args);
+        const unreleasedArgs = cacheInstance.value.unreleasedArgs;
+        if (unreleasedArgs && unreleasedArgs.length !== 0) {
+            this._resource.initiate(unreleasedArgs);
+        }
+        const uninitiatedCaches = new Set();
+        console.log({ uninitiatedCaches, fis: this._fis });
+        args.forEach(arg => {
+            const argKey = this._options.getArgKey(arg);
+            let fi = this._fis.get(argKey);
+            if (fi && !fi.cache.value.isInitiated) {
+                uninitiatedCaches.add(fi.cache);
+            }
+        });
+        uninitiatedCaches.forEach((c) => {
+            this._resource.initiate(c.value.args, { cache: c });
+        });
+        return cacheInstance;
+    }
+    serialize(args) {
+        if (!args)
+            return '';
+        const argsKeys = args.map(a => this._options.getArgKey(a));
+        return argsKeys.join('|');
+    }
+    compareArgs(a, b) {
+        return this.serialize(a) === this.serialize(b);
+    }
+    createAgent = () => {
+        return new ResourceDuplicatorAgent(this);
+    };
+    /** @deprecated */
+    d_init(args) {
+        const argsKeys = args.map(a => this._options.getArgKey(a));
+        const releasedCaches = new Set();
+        const unreleasedArgs = [];
+        args.forEach(arg => {
+            const argKey = this._options.getArgKey(arg);
+            let fi = this._fis.get(argKey);
+            if (!fi || !fi.cache.value.isInitiated) {
+                unreleasedArgs.push(arg);
+                return;
+            }
+            fi.k++;
+            releasedCaches.add(fi.cache);
+        });
+        const queryCache = this._resource.createQueryCache(unreleasedArgs);
+        unreleasedArgs.forEach(arg => {
+            const argKey = this._options.getArgKey(arg);
+            let fi = this._fis.get(argKey);
+            if (!fi) {
+                fi = {
+                    k: 1,
+                    cache: queryCache,
+                };
+                this._fis.set(argKey, fi);
+            }
+        });
+        return {
+            value$: Signal.compute(() => {
+                const itemsAcc = [
+                    queryCache.value$.get(),
+                ];
+                for (const rc of releasedCaches) {
+                    itemsAcc.push(rc.value$.get());
+                }
+                const isNotInitiated = itemsAcc.some(i => !i.isInitiated);
+                const baseReturn = {
+                    transactions: null,
+                    abortController: null,
+                    args,
+                    savedData: null,
+                    data: null,
+                    error: null,
+                    isError: false,
+                    isLoading: false,
+                    isReloading: false,
+                    isDone: false,
+                    isSuccess: false,
+                    isLocked: false,
+                    isInitiated: true,
+                    lockCount: 0,
+                    unreleasedArgs,
+                };
+                if (isNotInitiated)
+                    return {
+                        ...baseReturn,
+                        isInitiated: false,
+                    };
+                const isError = itemsAcc.some(i => i.isError);
+                if (isError) {
+                    const firstError = itemsAcc.find(i => i.isError);
+                    return {
+                        ...baseReturn,
+                        isError: true,
+                        isDone: true,
+                        error: firstError.error,
+                    };
+                }
+                const isLoading = itemsAcc.some(i => i.isLoading);
+                if (isLoading)
+                    return {
+                        ...baseReturn,
+                        isLoading: true,
+                    };
+                const dataAcc = [];
+                itemsAcc.forEach(item => {
+                    item.data?.forEach((d) => {
+                        const dataKey = this._options.getDataKey(d);
+                        const index = argsKeys.findIndex(ak => ak === dataKey);
+                        if (index === -1)
+                            return;
+                        dataAcc[index] = d;
+                    });
+                });
+                return {
+                    ...baseReturn,
+                    isSuccess: true,
+                    isDone: true,
+                    data: dataAcc,
+                };
+            }, { isDisabled: true }),
+        };
+    }
+}
+export class ComputedReactiveCache {
+    /**
+     * Реактивное значене (Observable)
+     */
+    value$;
+    /**
+     * Значение без сайд-эффектов (для использования в DevTools)
+     */
+    spy$;
+    /**
+     * Subject, уведомляющий об очистке кэша.
+     */
+    onClean$ = new Subject();
+    closed = false;
+    _getValue;
+    /**
+     * Создает новый экземпляр `ReactiveCacheItem`.
+     *
+     * @param options Параметры для настройки элемента кэша.
+     * @param options.initialState Начальное состояние кэша.
+     * @param options.cacheLifeTime Время жизни кэша в миллисекундах (по умолчанию 60_000).
+     */
+    constructor(options) {
+        const cacheLifeTime = options.cacheLifeTime ?? 60_000;
+        this.spy$ = options.obs.pipe(takeUntil(this.onClean$));
+        this.value$ = signalize(options.obs.pipe(finalize(() => {
+            this.complete();
+        }), share({
+            connector: () => new ReplaySubject(1),
+            resetOnRefCountZero: this._getOnRefCountZero(cacheLifeTime),
+            resetOnComplete: true,
+        })));
+        this._getValue = options.getValue;
+    }
+    _getOnRefCountZero(cacheLifeTime) {
+        if (cacheLifeTime === false) {
+            return false;
+        }
+        if (cacheLifeTime <= 0) {
+            return true;
+        }
+        return () => {
+            return timer(cacheLifeTime);
+        };
+    }
+    get value() {
+        return this._getValue();
+    }
+    /**
+     * Завершает работу кэша, закрывая все потоки и уведомляя об очистке.
+     */
+    complete() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.onClean$.next(this._getValue());
+        this.onClean$.complete();
+    }
+}

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

@@ -0,0 +1,35 @@
+import { ResourceAgentInstance } from "../../../query/types";
+import { ResourceDuplicator, DuplicatorDefinition } from "../../../query/core/Resource/ResourceDuplicator";
+export declare class ResourceDuplicatorAgent<D extends DuplicatorDefinition> implements ResourceAgentInstance<D['RESOURCE_DEFINITION']> {
+    private _resource;
+    private _resources$;
+    state$: import("../../../signals/types").ComputeFn<{
+        isInitiated: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isDone: boolean;
+        isSuccess: boolean;
+        isError: boolean;
+        isLocked: boolean;
+        isReloading: boolean;
+        error: undefined;
+        data: undefined;
+        args: D["ARGS_ITEM"][];
+    } | {
+        isInitiated: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isDone: boolean;
+        isSuccess: boolean;
+        isError: boolean;
+        isLocked: boolean;
+        isReloading: boolean;
+        error: {} | undefined;
+        data: NonNullable<D["RESOURCE_DEFINITION"]["Data"]> | undefined;
+        args: NonNullable<D["RESOURCE_DEFINITION"]["Args"]> | undefined;
+    }>;
+    constructor(_resource: ResourceDuplicator<D>);
+    initiate(args: D['ARGS_ITEM'][], force?: boolean): void;
+    compareArgs(args: D['ARGS_ITEM'][], otherArgs: D['ARGS_ITEM'][]): boolean;
+    private _next;
+}

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

@@ -0,0 +1,110 @@
+import { Computed, Signal } from "../../../signals";
+export class ResourceDuplicatorAgent {
+    _resource;
+    _resources$ = Signal.create({
+        previous$: null,
+        current$: null,
+    }, { isDisabled: true });
+    state$ = Computed.create(() => {
+        const resources = this._resources$.get();
+        let prevState;
+        const currState = resources.current$?.value$.get();
+        // Отлавливаем кейс, когда ресурс был спрошен.
+        // На данные момент единсвенная причина сброса - resetAllQueriesCache(),
+        //  но в будущем могут быть и другие причины, что потребует доработку.
+        if (currState && !currState.isInitiated) {
+            this._resource.initiate(currState.args, resources.current$);
+            return {
+                isInitiated: true,
+                isLoading: true,
+                isInitialLoading: true,
+                isDone: false,
+                isSuccess: false,
+                isError: false,
+                isReloading: false,
+                error: undefined,
+                data: undefined,
+                // TODO вообще нет точного представлния, как блокировака доложна работать.
+                //  Мб тут стоит брать currState.isLocked.
+                isLocked: false,
+                args: currState.args,
+            };
+        }
+        if (!currState?.isDone) {
+            prevState = resources.previous$?.value;
+        }
+        // Нет текущего состояния — дефолт
+        if (!currState) {
+            return {
+                isInitiated: false,
+                isLoading: false,
+                isInitialLoading: false,
+                isDone: false,
+                isSuccess: false,
+                isError: false,
+                isLocked: false,
+                isReloading: false,
+                error: undefined,
+                data: undefined,
+                args: undefined,
+            };
+        }
+        // Если идёт загрузка, но есть успешные данные из прошлого запроса — показываем их
+        const isShowPrev = currState.isLoading && prevState && prevState.isSuccess;
+        return {
+            isInitiated: currState.isInitiated || !!prevState,
+            isLoading: currState.isLoading,
+            isInitialLoading: currState.isLoading && !currState.isDone && !prevState?.isDone,
+            isDone: currState.isDone,
+            isSuccess: currState.isSuccess,
+            isError: currState.isError,
+            isLocked: currState.isLocked,
+            isReloading: currState.isReloading,
+            error: isShowPrev ? prevState.error ?? undefined : currState.error ?? undefined,
+            data: isShowPrev ? prevState.data ?? undefined : currState.data ?? undefined,
+            args: currState.args ?? undefined,
+        };
+    }, { isDisabled: true });
+    constructor(_resource) {
+        this._resource = _resource;
+    }
+    initiate(args, force = false) {
+        const current = this._resources$.peek().current$;
+        const cache = this._resource.getQueryCache(args);
+        if (!cache) {
+            const newCache = this._resource.initiate(args);
+            this._next(newCache);
+            return;
+        }
+        if (force || !(cache.value.isDone || cache.value.isLoading)) {
+            this._resource.initiate(args, cache);
+        }
+        if (current !== cache) {
+            this._next(cache);
+        }
+    }
+    compareArgs(args, otherArgs) {
+        return this._resource.compareArgs(args, otherArgs);
+    }
+    _next(newCache) {
+        const { previous$, current$ } = this._resources$.peek();
+        if (!current$) {
+            this._resources$.set({
+                previous$: null,
+                current$: newCache,
+            });
+            return;
+        }
+        if (!current$.value$.peek().isDone && previous$?.value$.peek().isDone) {
+            this._resources$.set({
+                previous$: previous$,
+                current$: newCache,
+            });
+            return;
+        }
+        this._resources$.set({
+            previous$: current$,
+            current$: newCache,
+        });
+    }
+}

package/dist/query/index.d.ts

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

package/dist/query/index.js

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

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

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

package/dist/query/react/useResourceAgent.js

@@ -12,9 +12,18 @@ export function useResourceAgent(res, ...argss) {
         }
         return agent;
     });
-    if (args !== SKIP && !agent.compareArgs(args, prevArgsRef.current)) {
+    if (!compare(args, prevArgsRef.current, agent)) {
         prevArgsRef.current = args;
         agent.initiate(args);
     }
     return useSignal(agent.state$);
 }
+function compare(args, prevArgs, agent) {
+    if (args === SKIP && prevArgs === SKIP) {
+        return true;
+    }
+    if (args === SKIP || prevArgs === SKIP) {
+        return false;
+    }
+    return agent.compareArgs(args, prevArgs);
+}

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

@@ -72,7 +72,7 @@ export type ResourceAgentInstance<D extends ResourceDefinition> = {
     /** Инициирует запрос с указанными аргументами */
     initiate(args: D["Args"], force?: boolean): void;
     /** Сравнивает аргументы между собой */
-    compareArgs(args1: D["Args"], args2: D["Args"]): unknown;
+    compareArgs(args1: D["Args"], args2: D["Args"]): boolean;
 };
 /**
  * Состояние запроса ресурса

package/docs/devtools/README.md

@@ -74,7 +74,7 @@ DefaultOptions.update({
 ```
 
 **Может пригодиться:**
-- Если в вашей среде неудобно или проблематично установить браузерное расширение
+- Если в вашей среде невозможно установить браузерное расширение
 - Для мобильной отладки
 
 ---
@@ -206,7 +206,7 @@ interface DevtoolsLike {
 }
 
 interface DevtoolsStateLike<T = any> {
-    (newState: T): void;
+    (newState: T | '$COMPLETED' | '$CLEANED'): void;
 }
 ```
 

package/docs/migrations/0.5.0.md

@@ -13,7 +13,7 @@ signal.value += 1;
 // Стало
 const signal = Signal.create(0);    // ✅
 const computed = Signal.compute(() => signal() * 2);    // ✅
-signal.set(signal.peek() + 1);
+signal.set(signal() + 1);
 ```
 
 

package/docs/options/README.md

@@ -42,7 +42,7 @@ DefaultOptions.update({
         // Логирование
         console.error('[RxToolkit Query Error]', error);
         
-        // Отправка в систему мониторинга
+        // Отправка в абстакную систему мониторинга
         Sentry.captureException(error, {
             tags: { source: 'rx-toolkit-query' }
         });
@@ -64,26 +64,27 @@ DefaultOptions.update({
 **Тип:** `(() => string | null) | null`  
 **По умолчанию:** `null`
 
-Функция для получения имени текущего scope. Полезно для SSR, изоляции данных между запросами или многопользовательских приложений.
+Функция для получения имени текущего scope.
+Можено, например, подключить к DI систему, для раширенного devtools нейминга.
 
 ```typescript
 import { DefaultOptions } from '@fozy-labs/rx-toolkit';
 
-// SSR: изоляция данных между запросами
-let currentRequestId: string | null = null;
-
 DefaultOptions.update({
-    getScopeName: () => currentRequestId
+    getScopeName: () => MyDiAbsractDi.getCurrentScopeName(),
 });
 
-// В middleware сервера
-app.use((req, res, next) => {
-    currentRequestId = req.id;
-    res.on('finish', () => {
-        currentRequestId = null;
-    });
-    next();
-});
+// Объявляем класс
+class Counter {
+    value$ = Signal.create(0, '{scope}/Counter/value$');
+}
+
+// В другом месте приложения
+function ChannelCounter() {
+    const counter = MyDiAbsractDi.resolve<Counter>('Counter', 'ChannelScope');
+    console.log(counter.value$()); // Devtools покажет имя сигнала как "ChannelScope/Counter/value$"
+    return null;
+} 
 ```
 
 ---

package/docs/signals/README.md

@@ -19,11 +19,11 @@ RxSignals — это реактивная система управления с
 ```typescript
 import { Signal } from '@fozy-labs/rx-toolkit';
 
-const name = new Signal('John');
-const age = new Signal(25);
+const name = Signal.create('John');
+const age = Signal.create(25);
 
 // Чтение значения (с отслеживанием зависимостей)
-console.log(name.get()); // "John"
+console.log(name()); // "John"
 
 // Чтение значения без отслеживания
 console.log(name.peek()); // "John"
@@ -41,7 +41,7 @@ subscription.unsubscribe();
 ```
 
 **API Signal:**
-- `get()` — получить значение и зарегистрировать зависимость (для использования внутри Computed/Effect)
+- `()`|`get()` — получить значение и зарегистрировать зависимость (для использования внутри Computed/Effect)
 - `peek()` — получить значение без регистрации зависимости
 - `set(value)` — установить новое значение
 - `obs` — RxJS Observable для подписки на изменения
@@ -51,58 +51,42 @@ subscription.unsubscribe();
 Создает вычисляемое значение, которое автоматически обновляется при изменении зависимостей.
 
 ```typescript
-import { Signal, Computed } from '@fozy-labs/rx-toolkit';
+import { Signal } from '@fozy-labs/rx-toolkit';
 
-const firstName = new Signal('John');
-const lastName = new Signal('Doe');
+const firstName = Signal.create('John');
+const lastName = Signal.create('Doe');
 
-const fullName = new Computed(() => `${firstName.get()} ${lastName.get()}`);
+const fullName = Signal.compute(() => `${firstName()} ${lastName()}`);
 
-console.log(fullName.get()); // "John Doe"
+console.log(fullName()); // "John Doe"
 
 firstName.set('Jane');
-console.log(fullName.get()); // "Jane Doe"
+console.log(fullName()); // "Jane Doe"
 
 // Подписка на изменения
 fullName.obs.subscribe(name => console.log(name));
 ```
 
 **API Computed:**
-- `get()` — получить вычисленное значение с регистрацией зависимости
+- `()`|`get()` — получить вычисленное значение с регистрацией зависимости
 - `peek()` — получить значение без регистрации зависимости
 - `obs` — RxJS Observable для подписки на изменения
 
 Также на данный момент Computed 
 
-+Важно: отличие от RxJS
-+
-+ - Computed: по умолчанию `Computed.obs` применяет `distinctUntilChanged()` — это значит, что подписчики не будут получать повторных эмиссий, если новое значение строго равно (`===`) предыдущему. Такое поведение предотвращает лишние рендеры и обработки, когда значение фактически не изменилось.
-+ - Signal: базовый `Signal` использует `BehaviorSubject` и при вызове `set()` будет эмитить значение независимо от того, изменилось оно или нет (если вам нужно предотвратить повторные эмиссии для сигнала, применяйте операторы RxJS к `signal.obs`, например `signal.obs.pipe(distinctUntilChanged())`).
-+
-+Пример: если у вас есть `const total = Signal.compute(() => a.get() + b.get())`, то при изменении `a` или `b` `total.obs` сработает только если новое значение суммы отличается от предыдущего (по `===`). Если нужен особый критерий сравнения, используйте `distinctUntilChanged` с собственной функцией сравнения:
-+
-+```ts
-+import { distinctUntilChanged } from 'rxjs';
-+
-+total.obs.pipe(distinctUntilChanged((prev, next) => /* ваша логика */));
-+```
-+
-+Рекомендация: рассчитывайте на то, что `Computed` избавляет от лишних эмиссий по-умолчанию; если вам нужно другое поведение, применяйте RxJS-операторы к `obs` или создавайте `Computed`, возвращающий другую форму данных (например объект с версией) для более тонкого контроля.
-+
-
 ### Effect
 
 Создает побочный эффект, который автоматически выполняется при изменении используемых сигналов.
 
 ```typescript
-import { Signal, Effect } from '@fozy-labs/rx-toolkit';
+import { Signal } from '@fozy-labs/rx-toolkit';
 
-const count = new Signal(0);
-const message = new Signal('Hello');
+const count = Signal.create(0);
+const message = Signal.create('Hello');
 
-const effect = new Effect(() => {
+const effect = Signal.effect(() => {
   // Выведет: "Hello: 0" при инициализации
-  console.log(`${message.get()}: ${count.get()}`);
+  console.log(`${message()}: ${count()}`);
 });
 
 count.set(1); // Выведет: "Hello: 1"
@@ -117,8 +101,9 @@ effect.unsubscribe();
 Effect поддерживает возврат функции очистки, которая вызывается перед следующим выполнением или при отписке:
 
 ```typescript
-const effect = new Effect(() => {
-  const timer = setInterval(() => console.log(count.get()), 1000);
+const effect = Signal.effect(() => {
+  count(); // Создаем подписку на count (тк не работает при асинхронных операциях)
+  const timer = setInterval(() => count(), 1000);
   
   // Cleanup - вызывается перед повторным выполнением эффекта
   return () => {
@@ -127,43 +112,35 @@ const effect = new Effect(() => {
 });
 ```
 
-## Функциональный стиль API
+## Функциональный vs классовый стиль
 
-Для более компактного синтаксиса доступны статические методы `Signal.create()`, `Signal.compute()` и `Signal.effect()`:
+RxSignals поддерживает как функциональный, так и классовый стили создания сигналов, позволяя выбрать подход в зависимости от предпочтений и архитектуры приложения.
+#### Функциональный стиль (рекомендуемый)
 
-```typescript
+Используйте статические методы `Signal.create`,`Signal.compute` и `Signal.effect` для создания сигналов. 
+Этот стиль лаконичен, похож на SolidJS и подходит для большинства случаев:
+
+```tszz
 import { Signal } from '@fozy-labs/rx-toolkit';
 
-class CounterStore {
-    // Создание сигнала в функциональном стиле (вызывается как функция)
-    count$ = Signal.create(0);
-    
-    // Computed в функциональном стиле
-    doubled$ = Signal.compute(() => this.count$() * 2);
-    squared$ = Signal.compute(() => (this.doubled$() / 2) ** 2);
-
-    increment = () => this.count$.set(this.count$.peek() + 1);
-    decrement = () => this.count$.set(this.count$.peek() - 1);
-    reset = () => this.count$.set(0);
-}
+const count = Signal.create(0);
+const doubled = Signal.compute(() => count() * 2);
+const logEffect = Signal.effect(() => console.log(doubled()));
+```
 
-const store = new CounterStore();
+#### Классовый стиль
 
-// Чтение значения - вызов как функции
-console.log(store.count$()); // 0
-console.log(store.doubled$()); // 0
+Создавайте экземпляры классов Signal, Computed и Effect напрямую.
+Этот стиль более явный, похож на RxJs и полезен для наследования или сложной логики,
+учтите, что вызов `()` недоступен и нужно использовать `get()`:
 
-store.increment();
-console.log(store.count$()); // 1
-console.log(store.doubled$()); // 2
-console.log(store.squared$()); // 1
-```
+```ts
+import { Signal, Computed, Effect } from '@fozy-labs/rx-toolkit';
 
-**API функциональных сигналов:**
-- `signal$()` — вызов как функции возвращает значение (аналог `get()`)
-- `signal$.peek()` — получить значение без отслеживания
-- `signal$.set(value)` — установить значение
-- `signal$.obs` — RxJS Observable
+const count = new Signal(0);
+const doubled = new Computed(() => count.get() * 2);
+const logEffect = new Effect(() => console.log(doubled.get()));
+```
 
 ### ReadonlySignal
 

package/docs/usage/react/README.md

@@ -246,8 +246,8 @@ class CounterStore {
     count$ = Signal.create(0, 'counter');
     doubled$ = Signal.compute(() => this.count$() * 2);
     
-    increment = () => this.count$.set(this.count$.peek() + 1);
-    decrement = () => this.count$.set(this.count$.peek() - 1);
+    increment = () => this.count$.set(this.count$() + 1);
+    decrement = () => this.count$.set(this.count$() - 1);
     reset = () => this.count$.set(0);
 }
 

package/package.json

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