@fozy-labs/rx-toolkit 0.4.18 → 0.5.0-rc.1

package/dist/signals/signals/Effect.js

@@ -1,87 +1,89 @@
-import { Batcher, Tracker } from "../base";
-import { SharedOptions } from "../../common/options/SharedOptions";
+import { Batcher, DependencyTracker } from "../base";
 export class Effect {
-    _onComplete;
-    _subscriptions = [];
+    _subscriptions = new Map();
     _teardown;
-    _scopeDestroyedSub = SharedOptions.getScopeDestroyed$?.()?.subscribe(() => {
-        this.complete();
-    });
     closed = false;
     _rang = 0;
-    constructor(effectFn, _onComplete) {
-        this._onComplete = _onComplete;
-        this._runInTrackedContext(effectFn, false);
+    constructor(effectFn) {
+        this._runInTrackedContext(effectFn);
     }
     /**
      * Выполняет функцию в tracked-контексте, подписываясь на Tracker.
      */
-    _runInTrackedContext(effectFn, isAsyncRun = false) {
-        let prevSubscriptions;
-        if (!isAsyncRun) {
-            // Вызываем teardown перед перезапуском эффекта
-            this._teardown?.();
-            this._teardown = undefined;
-            this._rang = 0;
-            prevSubscriptions = this._subscriptions;
-            this._subscriptions = [];
-        }
-        let isTrackedContext = true;
-        // TODO подумать как организовать планировщик при асинхронном запуске
+    _runInTrackedContext(effectFn) {
+        this._callTeardown();
+        this._rang = 0;
+        const legacySubscriptions = this._subscriptions;
+        this._subscriptions = new Map();
         let scheduler;
+        // Стабильная функция для планирования выполнения эффекта
         const scheduledFn = () => {
             this._runInTrackedContext(effectFn);
         };
-        // Подписываемся на Tracker. Во время выполнения подпишемся на все tracked наблюдатели.
-        const trackerSub = Tracker.tracked$.subscribe({
-            next: (tracked) => {
-                if (!isTrackedContext)
+        // Функция для проверки и создания подписки на зависимость
+        const checkSubscription = (obs) => {
+            if (this._subscriptions.has(obs)) {
+                return;
+            }
+            const legacySub = legacySubscriptions.get(obs);
+            if (legacySub) {
+                legacySubscriptions.delete(obs);
+                this._subscriptions.set(obs, legacySub);
+                return;
+            }
+            const sub = obs.subscribe(() => {
+                if (isTrackedContext) {
                     return;
-                if (tracked.rang <= this._rang) {
-                    this._rang = tracked.rang + 1;
                 }
-                this._subscriptions.push(tracked.obsv$.subscribe(() => {
-                    if (isTrackedContext) {
-                        return;
-                    }
-                    scheduler.schedule(scheduledFn);
-                }));
-            },
-            complete: () => {
-                this.complete();
-            },
-            error: (err) => {
-                console.error(err);
-                this.complete();
-            },
-        });
-        const teardown = effectFn((fn) => {
-            this._runInTrackedContext(fn, true);
+                scheduler.schedule(scheduledFn);
+            });
+            this._subscriptions.set(obs, sub);
+            return sub;
+        };
+        let isTrackedContext = true;
+        const stopTracking = DependencyTracker.start((dependency) => {
+            checkSubscription(dependency.obs);
+            const dependencyRang = dependency.getRang();
+            if (dependencyRang >= this._rang) {
+                this._rang = dependencyRang + 1;
+            }
         });
+        const optionalTeardown = effectFn();
+        stopTracking();
+        isTrackedContext = false;
         // Сохраняем teardown функцию, если она была возвращена
-        if (typeof teardown === 'function') {
-            this._teardown = teardown;
+        if (typeof optionalTeardown === 'function') {
+            this._teardown = optionalTeardown;
         }
-        trackerSub.unsubscribe();
-        isTrackedContext = false;
         scheduler = Batcher.scheduler(this._rang);
-        prevSubscriptions?.forEach((sub) => sub.unsubscribe());
+        legacySubscriptions?.forEach((sub) => {
+            sub.unsubscribe();
+        });
     }
-    complete() {
+    unsubscribe() {
         if (this.closed)
             return;
         this.closed = true;
         // Вызываем teardown перед завершением эффекта
-        this._teardown?.();
-        this._teardown = undefined;
+        this._callTeardown();
         this._subscriptions.forEach((sub) => sub.unsubscribe());
-        this._scopeDestroyedSub?.unsubscribe();
-        this._onComplete?.();
+    }
+    _getRang() {
+        return this._rang;
     }
     /**
-     * @deprecated Use `complete()` method instead.
+     * @deprecated Use `unsubscribe()` method instead.
      */
-    unsubscribe() {
-        this.complete();
+    complete() {
+        this.unsubscribe();
+    }
+    _callTeardown() {
+        if (this._teardown) {
+            this._teardown();
+            this._teardown = undefined;
+        }
+    }
+    static create(effectFn) {
+        return new Effect(effectFn);
     }
 }

package/dist/signals/signals/LocalSignal.d.ts

@@ -1,6 +1,7 @@
 import { ZodType } from "zod/v4";
 import { Observable } from "rxjs";
-import { Computed } from "../signals";
+import { SignalFn } from "../../signals/types";
+import { StateDevtoolsOptions } from "../../common/devtools";
 type Options<T> = {
     zodSchema?: ZodType<T>;
     key: string;
@@ -11,15 +12,21 @@ type Options<T> = {
     validator$?: Observable<(value: T) => boolean>;
     checkEffect?: (value: T) => boolean;
     defaultValue: T;
-    devtoolsName?: string | false;
+    devtoolsOptions?: StateDevtoolsOptions;
 };
-export declare class LocalSignal<T = string | null | number | undefined> extends Computed<T> {
-    private _options;
+export declare class LocalSignal<T = string | null | number | undefined> {
+    private _signal;
+    private _computed;
+    private readonly _options;
+    readonly obs: Observable<T>;
+    constructor(options: Options<T>);
+    set(value: T): void;
+    peek(): T;
+    get(): T;
     static KEY_PREFIX: string;
     static DRIVER: Storage;
-    private static _getStorageValue;
+    static create<T = string | null | number | undefined>(options: Options<T>): SignalFn<T>;
+    static _getStorageValue(options: Options<any>): any;
     private static _setStorageValue;
-    constructor(_options: Options<T>);
-    protected _onChange(value: T): void;
 }
 export {};

package/dist/signals/signals/LocalSignal.js

@@ -1,18 +1,66 @@
 import { z } from "zod/v4";
-import { Computed } from "../signals";
 import { signalize } from "../operators";
-const NullOrString = z.string().nullable();
+import { Signal } from "./Signal";
+import { Computed } from "./Computed";
 const NONE = Symbol('NONE');
-export class LocalSignal extends Computed {
+export class LocalSignal {
+    _signal;
+    _computed;
     _options;
+    obs;
+    constructor(options) {
+        let initialValue = LocalSignal._getStorageValue(options);
+        if (initialValue === NONE) {
+            initialValue = options.defaultValue;
+        }
+        this._signal = new Signal(initialValue, { isDisabled: true });
+        const validatorSignal$ = options.validator$ && signalize(options.validator$);
+        this._computed = new Computed(() => {
+            const value = this._signal.get();
+            if (validatorSignal$) {
+                const validator = validatorSignal$.get();
+                if (!validator(value)) {
+                    return options.defaultValue;
+                }
+            }
+            if (options.checkEffect) {
+                return options.checkEffect(value) ? value : options.defaultValue;
+            }
+            return value;
+        }, options.devtoolsOptions);
+        this.obs = this._computed.obs;
+        this._options = options;
+    }
+    set(value) {
+        LocalSignal._setStorageValue(this._options, value);
+        this._signal.set(value);
+    }
+    peek() {
+        return this._computed.peek();
+    }
+    get() {
+        return this._computed.get();
+    }
+    // === static ===
     static KEY_PREFIX = '__LSValue__';
     static DRIVER = localStorage;
+    static create(options) {
+        const localSignal = new LocalSignal(options);
+        function signalFn() {
+            return localSignal.get();
+        }
+        signalFn.peek = () => localSignal.peek();
+        signalFn.get = () => localSignal.get();
+        signalFn.set = (value) => localSignal.set(value);
+        signalFn.obs = localSignal.obs;
+        return signalFn;
+    }
     static _getStorageValue(options) {
         const storageKey = `${LocalSignal.KEY_PREFIX}:${options.key}`;
         const item = LocalSignal.DRIVER.getItem(storageKey);
         if (!item)
             return NONE;
-        const schema = z.record(z.string(), options.zodSchema || NullOrString);
+        const schema = z.record(z.string(), options.zodSchema || z.any());
         const parsed = schema.safeParse(JSON.parse(item));
         if (!parsed.success) {
             console.warn(`Invalid value for key "${options.key}" in localStorage`, parsed.error);
@@ -27,7 +75,7 @@ export class LocalSignal extends Computed {
     static _setStorageValue(options, value) {
         const storageKey = `${LocalSignal.KEY_PREFIX}:${options.key}`;
         const item = LocalSignal.DRIVER.getItem(storageKey) || '{}';
-        const schema = z.record(z.string(), options.zodSchema || NullOrString);
+        const schema = z.record(z.string(), options.zodSchema || z.any());
         const parsed = schema.safeParse(JSON.parse(item));
         let data = parsed.data ?? {};
         if (!parsed.success) {
@@ -37,35 +85,4 @@ export class LocalSignal extends Computed {
         data[subKey] = value;
         LocalSignal.DRIVER.setItem(storageKey, JSON.stringify(data));
     }
-    constructor(_options) {
-        const validator$ = _options.validator$;
-        const checkEffect = _options.checkEffect;
-        const defaultValue = _options.defaultValue;
-        const devtoolsName = _options.devtoolsName;
-        const validatorSignal$ = validator$ && signalize(validator$);
-        super(() => {
-            const value = LocalSignal._getStorageValue(_options);
-            if (value === NONE)
-                return defaultValue;
-            if (validatorSignal$) {
-                const validator = validatorSignal$.value;
-                if (!validator(value)) {
-                    return defaultValue;
-                }
-            }
-            if (checkEffect) {
-                return checkEffect(value) ? value : defaultValue;
-            }
-            return value;
-        }, {
-            isDisabled: devtoolsName === false,
-            base: 'LocalSignals',
-            name: devtoolsName || undefined,
-        });
-        this._options = _options;
-    }
-    _onChange(value) {
-        LocalSignal._setStorageValue(this._options, value);
-        return super._onChange(value);
-    }
 }

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

@@ -1,43 +1,19 @@
-import { BehaviorSubject, Observable, SubscriptionLike } from "rxjs";
-import { ReadableSignalLike, SignalLike, UnaryFunction } from "../base";
+import { BehaviorSubject } from "rxjs";
 import { StateDevtoolsOptions } from "../../common/devtools";
-export declare class Signal<T> extends BehaviorSubject<T> implements SubscriptionLike, SignalLike<T> {
+import { SignalFn } from "../../signals/types";
+import { Effect } from "../../signals";
+export declare class Signal<T> {
     private readonly _stateDevtools;
-    protected _rang: number;
-    protected readonly _scopeDestroyedSub: import("rxjs").Subscription | undefined;
+    private _rang;
+    protected readonly bs$: BehaviorSubject<T>;
+    readonly obs: import("rxjs").Observable<T>;
     constructor(initialValue: T, options?: StateDevtoolsOptions);
-    protected _onChange(value: T): void;
-    get value(): T;
-    set value(value: T);
-    next(value: T): void;
     peek(): T;
-    /**
-     * @deprecated use `value` instead.
-     */
-    get(): T;
-    /**
-     * @deprecated use `peek()` instead.
-     */
-    getValue(): T;
-    /**
-     * @deprecated use `next(value)` instead.
-     */
     set(value: T): void;
-    complete(): void;
-    /**
-     * @deprecated use `complete()` instead.
-     */
-    unsubscribe(): void;
-    asReadonly(): ReadableSignalLike<T>;
-    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;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>): C;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>): D;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>, E extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>): E;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>, E extends Observable<any>, F extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>): F;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>, E extends Observable<any>, F extends Observable<any>, G extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>): G;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>, E extends Observable<any>, F extends Observable<any>, G extends Observable<any>, H extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>, op8: UnaryFunction<G, H>): H;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>, E extends Observable<any>, F extends Observable<any>, G extends Observable<any>, H extends Observable<any>, I extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>, op8: UnaryFunction<G, H>, op9: UnaryFunction<H, I>): I;
-    pipe<A extends Observable<any>, B extends Observable<any>, C extends Observable<any>, D extends Observable<any>, E extends Observable<any>, F extends Observable<any>, G extends Observable<any>, H extends Observable<any>, I extends Observable<any>>(op1: UnaryFunction<Signal<T>, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>, op8: UnaryFunction<G, H>, op9: UnaryFunction<H, I>, ...operations: UnaryFunction<Observable<any>, Observable<any>>[]): Observable<unknown>;
+    get(): T;
+    protected _onChange(value: T): void;
+    private static _finalizationRegistry;
+    static create<T>(initialValue: T, options?: StateDevtoolsOptions): SignalFn<T>;
+    static compute<T>(computeFn: () => T, options?: StateDevtoolsOptions): import("../../signals/types").ComputeFn<T>;
+    static effect(effectFn: () => void): Effect;
 }

package/dist/signals/signals/Signal.js

@@ -1,74 +1,60 @@
 import { BehaviorSubject } from "rxjs";
-import { Batcher, Tracker, Devtools } from "../base";
-import { SharedOptions } from "../../common/options/SharedOptions";
-export class Signal extends BehaviorSubject {
+import { Computed, Effect } from "../../signals";
+import { Batcher, DependencyTracker, Devtools } from "../base";
+export class Signal {
     _stateDevtools;
     _rang = 0;
-    _scopeDestroyedSub = SharedOptions.getScopeDestroyed$?.()?.subscribe(() => {
-        this.complete();
-    });
+    bs$;
+    obs;
     constructor(initialValue, options) {
-        super(initialValue);
+        this.bs$ = new BehaviorSubject(initialValue);
+        this.obs = this.bs$.asObservable();
         this._stateDevtools = Devtools.createState(initialValue, {
-            base: 'Signals',
+            base: Signal.name,
             ...(typeof options === 'string' ? { name: options } : options)
         });
-    }
-    _onChange(value) {
-        Batcher.batch(() => {
-            this._stateDevtools?.(value);
-            super.next(value);
-        });
-    }
-    get value() {
-        Tracker.next(this._rang, this);
-        return super.value;
-    }
-    set value(value) {
-        this._onChange(value);
-    }
-    next(value) {
-        this._onChange(value);
+        if (this._stateDevtools) {
+            Signal._finalizationRegistry.register(this, this._stateDevtools);
+        }
     }
     peek() {
-        return super.value;
-    }
-    /**
-     * @deprecated use `value` instead.
-     */
-    get() {
-        return this.value;
+        return this.bs$.getValue();
     }
-    /**
-     * @deprecated use `peek()` instead.
-     */
-    getValue() {
-        return super.getValue();
-    }
-    /**
-     * @deprecated use `next(value)` instead.
-     */
     set(value) {
-        return this.next(value);
-    }
-    complete() {
-        this._stateDevtools?.('$COMPLETED');
-        this._scopeDestroyedSub?.unsubscribe();
-        super.complete();
+        return this._onChange(value);
     }
-    /**
-     * @deprecated use `complete()` instead.
-     */
-    unsubscribe() {
-        this.complete();
+    get() {
+        DependencyTracker.track({
+            getRang: () => this._rang,
+            obs: this.obs,
+        });
+        return this.bs$.getValue();
     }
-    asReadonly() {
-        return this;
+    _onChange(value) {
+        Batcher.run(() => {
+            this._stateDevtools?.(value);
+            this.bs$.next(value);
+        });
     }
-    pipe(...operations) {
-        return operations.reduce(pipeReducer, this);
+    // === static ===
+    static _finalizationRegistry = new FinalizationRegistry((heldValue) => {
+        heldValue('$COMPLETED');
+    });
+    static create(initialValue, options) {
+        const ls = new Signal(initialValue, options);
+        function signalFn() {
+            return ls.get();
+        }
+        signalFn.peek = () => ls.peek();
+        signalFn.set = (value) => ls.set(value);
+        signalFn.get = () => ls.get();
+        signalFn.obs = ls.obs;
+        return signalFn;
+    }
+    static compute(computeFn, options) {
+        return Computed.create(computeFn, options);
+    }
+    static effect(effectFn) {
+        return Effect.create(effectFn);
     }
 }
-function pipeReducer(prev, fn) {
-    return fn(prev);
-}

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

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

package/dist/signals/types/index.js

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

package/dist/signals/types/signals.types.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from "rxjs";
+export interface ReadableSignalLike<T> {
+    readonly obs: Observable<T>;
+    peek(): T;
+    get(): T;
+}
+export interface ReadableSignalFnLike<T> extends ReadableSignalLike<T> {
+    (): T;
+}
+export interface WriteableSignalLike<T> {
+    set(value: T): void;
+}
+export interface SignalFn<T> extends ReadableSignalFnLike<T>, WriteableSignalLike<T> {
+}
+export interface ComputeFn<T> extends ReadableSignalFnLike<T> {
+}

package/docs/CHANGELOG.md

@@ -0,0 +1,32 @@
+# CHANGELOG
+
+## Что нового в 0.5.0
+
+[Гайд по миграции](./migrations/0.5.0.md)
+
+### RxSignals
+
+- **Функциональный API (рекомендуется)**: `Signal.create()`, `Signal.compute()`, `Signal.effect()`
+- **Cleanup функции в Effect**: поддержка возврата teardown функции
+- **Без complete()**: теперь нет необходимости вызывать `complete()` для Signal и Computed
+- **Ленивый Computed**: вычисление только при наличии подписок
+
+### RxQuery
+
+- **Расширенные состояния**: `isInitialLoading`, `isReloading`, `isLocked`
+- **ResourceRef API**: низкоуровневый доступ к кэшу с поддержкой транзакций
+- **Patch транзакции**: изменения с возможностью commit/abort
+- **Lifecycle хуки**: `onCacheEntryAdded`, `onQueryStarted`
+- **resetAllQueriesCache()**: сброс всего кэша
+
+### React
+
+- **useResourceRef**: хук для работы с ResourceRef
+
+### Devtools
+
+- **BatchStrategy**: настройка стратегии обновлений (`'sync'`, `'microtask'`, `'task'`)
+
+### Конфигурация
+
+- **DefaultOptions**: расширенная конфигурация (`onQueryError`, `getScopeName`)