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

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

@@ -1,5 +1,2 @@
 export * from './useConstant';
 export * from './useEventHandler';
-export * from './useObservable';
-export * from './useSyncObservable';
-export * from './useUnmount';

package/dist/common/react/index.js

@@ -1,5 +1,2 @@
 export * from './useConstant';
 export * from './useEventHandler';
-export * from './useObservable';
-export * from './useSyncObservable';
-export * from './useUnmount';

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

@@ -0,0 +1,17 @@
+/**
+ * Кеш для хранения вычисленного значения и его зависимостей
+ */
+export declare class ComputeCache<T> {
+    private static _NO_VALUE;
+    private _cachedValue;
+    private _dependencies;
+    /**
+     * Проверяет, изменились ли зависимости с момента последнего вычисления
+     */
+    isValid(): boolean;
+    /**
+     * Получает кешированное значение или вычисляет новое
+     */
+    getOrCompute(computeFn: () => T): T;
+    clear(): void;
+}

package/dist/signals/base/ComputeCache.js

@@ -0,0 +1,64 @@
+import { DependencyTracker } from "../../signals";
+/**
+ * Кеш для хранения вычисленного значения и его зависимостей
+ */
+export class ComputeCache {
+    static _NO_VALUE = Symbol('no-value');
+    _cachedValue = ComputeCache._NO_VALUE;
+    _dependencies = [];
+    /**
+     * Проверяет, изменились ли зависимости с момента последнего вычисления
+     */
+    isValid() {
+        if (this._cachedValue === ComputeCache._NO_VALUE) {
+            return false;
+        }
+        // Проверяем, что все зависимости имеют те же значения
+        return this._dependencies.every(dep => {
+            try {
+                const currentValue = dep.peek();
+                return Object.is(currentValue, dep.lastValue);
+            }
+            catch {
+                // Если не удалось получить значение, считаем кеш невалидным
+                return false;
+            }
+        });
+    }
+    /**
+     * Получает кешированное значение или вычисляет новое
+     */
+    getOrCompute(computeFn) {
+        if (this.isValid()) {
+            return this._cachedValue;
+        }
+        // Собираем зависимости во время вычисления
+        const dependencies = [];
+        const stopTracking = DependencyTracker.start((dep) => {
+            // Создаем peek-функцию для этой зависимости
+            dependencies.push({
+                peek: dep.peek,
+                lastValue: undefined, // Будет установлено после первого peek
+            });
+        });
+        try {
+            // Вычисляем значение
+            const result = computeFn();
+            // Получаем текущие значения зависимостей
+            dependencies.forEach(dep => {
+                dep.lastValue = dep.peek();
+            });
+            // Сохраняем результат и зависимости
+            this._cachedValue = result;
+            this._dependencies = dependencies;
+            return result;
+        }
+        finally {
+            stopTracking();
+        }
+    }
+    clear() {
+        this._cachedValue = ComputeCache._NO_VALUE;
+        this._dependencies = [];
+    }
+}

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

@@ -6,6 +6,7 @@ export type DependencyRecord = {
      */
     getRang(): number;
     obs: Observable<unknown>;
+    peek: () => unknown;
     /**
      * Зарезервировано для отладки и логирования.
      */

package/dist/signals/base/ReadonlySignal.js

@@ -10,6 +10,7 @@ export class ReadonlySignal {
         DependencyTracker.track({
             getRang: () => this.rang,
             obs: this.obs,
+            peek: () => this.peek(),
         });
         return this.obs.value;
     }

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

@@ -1,4 +1,5 @@
 export * from './Batcher';
+export * from './ComputeCache';
 export * from './DependencyTracker';
 export * from './Devtools';
 export * from './ReadonlySignal';

package/dist/signals/base/index.js

@@ -1,4 +1,5 @@
 export * from './Batcher';
+export * from './ComputeCache';
 export * from './DependencyTracker';
 export * from './Devtools';
 export * from './ReadonlySignal';

package/dist/signals/react/useSignal.d.ts

@@ -1,6 +1,7 @@
 import { Observable } from "rxjs";
 type SignalLike<T> = {
     obs: Observable<T>;
+    peek: () => T;
 };
 export declare function useSignal<T>(signal$: SignalLike<T>): T;
 export {};

package/dist/signals/react/useSignal.js

@@ -1,4 +1,16 @@
-import { useSyncObservable } from "../../common/react";
+import React from "react";
+import { useEventHandler } from "../../common/react";
 export function useSignal(signal$) {
-    return useSyncObservable(signal$.obs);
+    const subscribe = React.useCallback((update) => {
+        const subscription = signal$.obs.subscribe(() => {
+            update();
+        });
+        return () => {
+            subscription.unsubscribe();
+        };
+    }, [signal$]);
+    const getSnapshot = useEventHandler(() => {
+        return signal$.peek();
+    });
+    return React.useSyncExternalStore(subscribe, getSnapshot);
 }

package/dist/signals/signals/Computed.d.ts

@@ -2,11 +2,14 @@ import { StateDevtoolsOptions } from "../../common/devtools";
 import { ComputeFn } from "../../signals/types";
 export declare class Computed<T> {
     private _computeFn;
-    private options?;
     private _ls;
     readonly obs: import("rxjs").Observable<T>;
     private _effect;
-    constructor(_computeFn: () => T, options?: StateDevtoolsOptions | undefined);
+    /**
+     * Кеш для хранения вычисленного значения (без подписки) и его зависимостей
+     */
+    private _computeCache;
+    constructor(_computeFn: () => T, options?: StateDevtoolsOptions);
     get(): T;
     peek(): T;
     private _start;

package/dist/signals/signals/Computed.js

@@ -1,15 +1,18 @@
 import { distinctUntilChanged, ReplaySubject, share, map, finalize } from "rxjs";
-import { DependencyTracker, Signal } from "../../signals";
+import { ComputeCache, DependencyTracker } from "../base";
 import { Effect } from "./Effect";
+import { Signal } from "./Signal";
 export class Computed {
     _computeFn;
-    options;
     _ls;
     obs;
     _effect = null;
+    /**
+     * Кеш для хранения вычисленного значения (без подписки) и его зависимостей
+     */
+    _computeCache = new ComputeCache();
     constructor(_computeFn, options) {
         this._computeFn = _computeFn;
-        this.options = options;
         const lsOptions = {
             base: Computed.name,
             ...(typeof options === 'string' ? { name: options } : options),
@@ -38,17 +41,15 @@ export class Computed {
                 return this._effect._getRang();
             },
             obs: this.obs,
+            peek: () => this.peek(),
         });
-        const v = this._ls.peek();
-        if (v === Computed._EMPTY) {
-            return this._computeFn();
-        }
-        return v;
+        return this.peek();
     }
     peek() {
         const v = this._ls.peek();
         if (v === Computed._EMPTY) {
-            return this._computeFn();
+            // Используем кеш для вычисления без создания подписки
+            return this._computeCache.getOrCompute(this._computeFn);
         }
         return v;
     }
@@ -62,6 +63,7 @@ export class Computed {
             }
             this._ls.set(this._computeFn());
         });
+        this._computeCache.clear();
         if (initialValue === Computed._EMPTY) {
             throw new Error('Computed value is not initialized');
         }

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

@@ -11,7 +11,6 @@ export declare class Signal<T> {
     peek(): T;
     set(value: T): void;
     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>;

package/dist/signals/signals/Signal.js

@@ -21,21 +21,22 @@ export class Signal {
         return this.bs$.getValue();
     }
     set(value) {
-        return this._onChange(value);
+        if (value === this.bs$.value) {
+            return;
+        }
+        Batcher.run(() => {
+            this._stateDevtools?.(value);
+            this.bs$.next(value);
+        });
     }
     get() {
         DependencyTracker.track({
             getRang: () => this._rang,
             obs: this.obs,
+            peek: () => this.peek(),
         });
         return this.bs$.getValue();
     }
-    _onChange(value) {
-        Batcher.run(() => {
-            this._stateDevtools?.(value);
-            this.bs$.next(value);
-        });
-    }
     // === static ===
     static _finalizationRegistry = new FinalizationRegistry((heldValue) => {
         heldValue('$COMPLETED');

package/docs/migrations/0.5.0.md

@@ -1,17 +1,22 @@
 # Миграция с версии 0.4.x на 0.5.0
 
-### Сигналы больше не наследуются от Observable
+
+### Новый функциональный API для создания сигналов
 
 ```typescript
 // Было
-signal.subscribe(fn); // ❌
-signal.pipe()         // ❌
+const signal = new Signal(0);    // ❌
+const computed = new Computed(() => signal.value * 2);   // ❌
+signal.value += 1;
+
 
 // Стало
-signal.obs.subscribe(fn); // ✅
-signal.obs.pipe()         // ✅
+const signal = Signal.create(0);    // ✅
+const computed = Signal.compute(() => signal() * 2);    // ✅
+signal.set(signal.peek() + 1);
 ```
 
+
 ### Сигналы больше не поддерживают `value`, `getValue()` и `next()`
 
 ```typescript
@@ -26,21 +31,16 @@ signal()         // ✅
 signal.get();    // ✅
 signal.set(val); // ✅
 ```
+### Сигналы больше не наследуются от Observable
 
-### Computed, на который нет подписок, пересчитывается при каждом обращении.
-
-```typescripttypescript
+```typescript
 // Было
-const comp$ = new Computed(() => myHeavyCalc(singal.value)); // ✅ пересчитывается
-comp$.get();                // ✅ берется из кеша
-comp.subscribe(() => {});   // ✅ берется из кеша
-comp$.get();                // ✅ берется из кеша
+signal.subscribe(fn); // ❌
+signal.pipe()         // ❌
 
 // Стало
-const comp$ = Signal.compute(() => myHeavyCalc(singal())); // ✅ ждет
-comp$.get();                // ✅ пересчитывается
-comp$.subscribe(() => {});  // ✅ пересчитывается
-comp$.get();                // ✅ берется из кеша
+signal.obs.subscribe(fn); // ✅
+signal.obs.pipe()         // ✅
 ```
 
 ### Нет необходимости вызывать `complete()` для Signal и Computed
@@ -56,18 +56,3 @@ const signal = Signal.create(0);
 // Что-то делаем
 // Ничего не нужно вызывать  ✅
 ```
-
-### Новый функциональный API для создания сигналов (рекомендуется)
-
-```typescript
-// Было
-const signal = new Signal(0);
-const computed = new Computed(() => signal.value * 2);
-signal.value += 1; // ❌
-
-
-// Стало
-const signal = Signal.create(0);
-const computed = Signal.compute(() => signal() * 2);
-signal.set(signal.peek() + 1); // ✅
-```

package/docs/signals/README.md

@@ -4,6 +4,12 @@ RxSignals — это реактивная система управления с
 
 ## Основные концепции
 
+### Реактивность на основе значений
+
+Сигналы (`Signal`) хранят текущее состояние, а производные сущности (`Computed`, `Effect`) автоматически отслеживают зависимости,
+применяея кеширование на основе *значений*. Это приводит к тому, что в отличие от классического RxJS-подхода, 
+где каждое `next()` — это событие, в RxSignals важен именно факт *изменения значения*.
+
 ### Signal
 
 Базовый класс для создания реактивных сигналов с изменяемым состоянием.
@@ -66,6 +72,24 @@ fullName.obs.subscribe(name => console.log(name));
 - `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
 
 Создает побочный эффект, который автоматически выполняется при изменении используемых сигналов.
@@ -292,4 +316,3 @@ const user$ = Signal.create(null, {
 ## React интеграция
 
 См. [React интеграция](../usage/react/README.md) для подробной информации о том, как использовать RxSignals в React приложениях.
-

package/docs/usage/react/README.md

@@ -34,55 +34,6 @@ function Counter() {
 - Автоматическая подписка и отписка при размонтировании
 - Не вызывает ре-рендер, если значение не изменилось
 
-### useObservable
-
-Подписывается на RxJS Observable и возвращает текущее значение.
-
-```tsx
-import { useObservable } from '@fozy-labs/rx-toolkit';
-import { interval, map } from 'rxjs';
-
-const timer$ = interval(1000).pipe(
-    map(count => `Timer: ${count}`)
-);
-
-function Timer() {
-    const timerValue = useObservable(timer$, 'Timer: 0');
-    
-    return <div>{timerValue}</div>;
-}
-```
-
-**Параметры:**
-- `observable$` — RxJS Observable для подписки
-- `initialValue` — начальное значение до первой эмиссии
-
-**Особенности:**
-- Требует начальное значение, если Observable асинхронный
-- Автоматическая переподписка при смене Observable
-
-### useSyncObservable
-
-Синхронная версия `useObservable` для Observable, которые могут выдать значение немедленно.
-
-```tsx
-import { useSyncObservable } from '@fozy-labs/rx-toolkit';
-import { BehaviorSubject } from 'rxjs';
-
-const data$ = new BehaviorSubject('initial data');
-
-function DataComponent() {
-    const data = useSyncObservable(data$);
-    
-    return <div>Data: {data}</div>;
-}
-```
-
-**Отличия от useObservable:**
-- Не требует начального значения
-- Подходит для BehaviorSubject, ReplaySubject и сигналов
-- Выбросит ошибку, если Observable не эмитит значение синхронно
-
 ---
 
 ## RxQuery хуки

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fozy-labs/rx-toolkit",
-  "version": "0.5.0-rc.1",
+  "version": "0.5.0-rc.2",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -57,6 +57,7 @@
   },
   "preferGlobal": false,
   "dependencies": {
-    "immer": "^10.1.3"
+    "immer": "^10.1.3",
+    "observable-hooks": "^4.2.4"
   }
 }

package/dist/common/react/useObservable.d.ts

@@ -1,12 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * Hook for automatically subscribing and unsubscribing from an Observable.
- * If the Observable synchronously returns a value, it returns it.
- * Else returns initialValue.
- * If the value of the Observable changes, it resubscribes.
- * If a value equal to the previous one arrives in the Observable,
- *   the previous value is returned without triggering a re-render.
- * @param input$ Observable.
- * @param initialValue Initial value that will be used before the Observable emits a value.
- */
-export declare function useObservable<T>(input$: Observable<T>, initialValue: T): T;

package/dist/common/react/useObservable.js

@@ -1,48 +0,0 @@
-import React from 'react';
-import { BehaviorSubject } from 'rxjs';
-import { useConstant } from "./useConstant";
-import { useEventHandler } from "./useEventHandler";
-const NONE = Symbol('NONE');
-/**
- * Hook for automatically subscribing and unsubscribing from an Observable.
- * If the Observable synchronously returns a value, it returns it.
- * Else returns initialValue.
- * If the value of the Observable changes, it resubscribes.
- * If a value equal to the previous one arrives in the Observable,
- *   the previous value is returned without triggering a re-render.
- * @param input$ Observable.
- * @param initialValue Initial value that will be used before the Observable emits a value.
- */
-export function useObservable(input$, initialValue) {
-    const { subject$, subscription } = useConstant(() => {
-        const subject = new BehaviorSubject(NONE);
-        /**
-         * Check if the Observable synchronously returns a value,
-         *  like BehaviorSubject or etc.
-         */
-        const subscription = input$
-            .subscribe((value) => subject.next(value));
-        return {
-            subject$: subject,
-            subscription,
-        };
-    }, [input$]);
-    React.useEffect(() => {
-        return () => {
-            subscription.unsubscribe();
-            subject$.complete();
-        };
-    }, [subject$]);
-    const subscribe = React.useCallback((updateStore) => {
-        const subjectSubscription = subject$.subscribe(updateStore);
-        return () => {
-            subjectSubscription.unsubscribe();
-        };
-    }, [input$, subject$]);
-    const getSnapshot = useEventHandler(() => subject$.getValue());
-    let value = React.useSyncExternalStore(subscribe, getSnapshot);
-    if (value === NONE) {
-        value = initialValue;
-    }
-    return value;
-}

package/dist/common/react/useSyncObservable.d.ts

@@ -1,16 +0,0 @@
-import { Observable } from 'rxjs';
-declare const NONE: unique symbol;
-/**
- * Hook for automatically subscribing and unsubscribing from an Observable.
- * If the Observable synchronously returns a value, it returns it.
- * Else if initialValue is provided, it returns it.
- * Else (if initialValue is NONE and the Observable does not synchronously return a value),
- *   throws error.
- * If the value of the Observable changes, it resubscribes.
- * If a value equal to the previous one arrives in the Observable,
- *   the previous value is returned without triggering a re-render.
- * @param input$ Observable.
- * @param initialValue Initial value that will be used before the Observable emits a value.
- */
-export declare function useSyncObservable<T>(input$: Observable<T>, initialValue?: T | typeof NONE): T;
-export {};

package/dist/common/react/useSyncObservable.js

@@ -1,52 +0,0 @@
-import React from 'react';
-import { BehaviorSubject } from 'rxjs';
-import { useConstant } from "./useConstant";
-import { useEventHandler } from "./useEventHandler";
-import { useUnmount } from "../../common/react/useUnmount";
-const NONE = Symbol('NONE');
-/**
- * Hook for automatically subscribing and unsubscribing from an Observable.
- * If the Observable synchronously returns a value, it returns it.
- * Else if initialValue is provided, it returns it.
- * Else (if initialValue is NONE and the Observable does not synchronously return a value),
- *   throws error.
- * If the value of the Observable changes, it resubscribes.
- * If a value equal to the previous one arrives in the Observable,
- *   the previous value is returned without triggering a re-render.
- * @param input$ Observable.
- * @param initialValue Initial value that will be used before the Observable emits a value.
- */
-export function useSyncObservable(input$, initialValue = NONE) {
-    const { subject$, subscription } = useConstant(() => {
-        const subject = new BehaviorSubject(NONE);
-        /**
-         * Check if the Observable synchronously returns a value,
-         *  like BehaviorSubject or etc.
-         */
-        const subscription = input$
-            .subscribe((value) => subject.next(value));
-        return {
-            subject$: subject,
-            subscription,
-        };
-    }, [input$]);
-    useUnmount(() => {
-        subscription.unsubscribe();
-        subject$.complete();
-    }, [subject$]);
-    const subscribe = React.useCallback((updateStore) => {
-        const subjectSubscription = subject$.subscribe(updateStore);
-        return () => {
-            subjectSubscription.unsubscribe();
-        };
-    }, [input$, subject$]);
-    const getSnapshot = useEventHandler(() => subject$.getValue());
-    let value = React.useSyncExternalStore(subscribe, getSnapshot);
-    if (value === NONE) {
-        value = initialValue;
-    }
-    if (value === NONE) {
-        throw new Error('Observable did not return a value and no initial value provided');
-    }
-    return value;
-}

package/dist/common/react/useUnmount.d.ts

@@ -1 +0,0 @@
-export declare function useUnmount(fn: () => void, deps?: any[]): void;

package/dist/common/react/useUnmount.js

@@ -1,24 +0,0 @@
-import React from "react";
-export function useUnmount(fn, deps = []) {
-    const preventUnmountRef = React.useRef(null);
-    React.useEffect(() => {
-        return () => {
-            let isPrevented = false;
-            preventUnmountRef.current = () => {
-                isPrevented = true;
-            };
-            new Promise((resolve) => {
-                resolve();
-            }).then(() => {
-                if (isPrevented)
-                    return;
-                preventUnmountRef.current = null;
-                fn();
-            });
-        };
-    }, deps);
-    React.useEffect(() => {
-        preventUnmountRef.current?.();
-        preventUnmountRef.current = null;
-    }, deps);
-}