@fozy-labs/rx-toolkit 0.5.2 → 0.5.3-rc.1

package/dist/common/options/DefaultOptions.d.ts

@@ -1,4 +1,4 @@
-import type { DevtoolsLike } from "../../common/devtools";
+import type { DevtoolsLike } from "@/common/devtools";
 type Update = Partial<{
     DEVTOOLS: DevtoolsLike | null;
     onQueryError: (error: unknown) => void;

package/dist/common/options/SharedOptions.d.ts

@@ -1,5 +1,5 @@
-import { DevtoolsLike } from "../../common/devtools";
-import { shallowEqual } from "../../common/utils";
+import { DevtoolsLike } from "@/common/devtools";
+import { shallowEqual } from "@/common/utils";
 export declare class SharedOptions {
     static DEVTOOLS: DevtoolsLike | null;
     static onQueryError: ((error: unknown) => void) | null;

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

@@ -1,3 +1,3 @@
-import type { OperationCreateOptions, OperationDefinition } from "../../query/types";
-import { Operation } from "../../query/core/Opertation/Operation";
+import type { OperationCreateOptions, OperationDefinition } from "@/query/types";
+import { Operation } from "@/query/core/Opertation/Operation";
 export declare const createOperation: <ARGS, RESULT, SELECTED = never>(options: OperationCreateOptions<OperationDefinition<ARGS, RESULT, SELECTED>>) => Operation<OperationDefinition<ARGS, RESULT, SELECTED>>;

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

@@ -1,3 +1,3 @@
-import type { ResourceCreateOptions, ResourceDefinition } from "../../query/types";
-import { Resource } from "../../query/core/Resource/Resource";
+import type { ResourceCreateOptions, ResourceDefinition } from "@/query/types";
+import { Resource } from "@/query/core/Resource/Resource";
 export declare const createResource: <ARGS, RESULT, SELECTED = never>(options: ResourceCreateOptions<ResourceDefinition<ARGS, RESULT, SELECTED>>) => Resource<ResourceDefinition<ARGS, RESULT, SELECTED>>;

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

@@ -1,4 +1,4 @@
-import { DuplicatorOptions, ResourceDuplicator, DuplicatorDefinition } from "../../query/core/Resource/ResourceDuplicator";
-import { ResourceDefinition } from "../../query/types";
+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/core/Opertation/Operation.d.ts

@@ -1,5 +1,5 @@
-import type { ReactiveCache } from "../../../query/lib/ReactiveCache";
-import type { FallbackOnNever, OperationCreateOptions, OperationDefinition, OperationInstance } from "../../../query/types";
+import type { ReactiveCache } from "@/query/lib/ReactiveCache";
+import type { FallbackOnNever, OperationCreateOptions, OperationDefinition, OperationInstance } from "@/query/types";
 import { OperationAgent } from "./OperationAgent";
 export type CoreOperationQueryState<D extends OperationDefinition> = {
     arg: D['Args'] | null;

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

@@ -1,4 +1,4 @@
-import { OperationAgentInstanse, OperationDefinition } from "../../../query/types";
+import { OperationAgentInstanse, OperationDefinition } from "@/query/types";
 import type { Operation } from "./Operation";
 export declare class OperationAgent<D extends OperationDefinition> implements OperationAgentInstanse<D> {
     private _operation;
@@ -9,7 +9,7 @@ export declare class OperationAgent<D extends OperationDefinition> implements Op
         isSuccess: boolean;
         isError: boolean;
         error: {} | undefined;
-        data: NonNullable<import("../../../query/types").FallbackOnNever<D["Selected"], D["Result"]>> | undefined;
+        data: NonNullable<import("@/query/types").FallbackOnNever<D["Selected"], D["Result"]>> | undefined;
         args: D["Args"];
     }>;
     constructor(_operation: Operation<D>);

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

@@ -1,4 +1,4 @@
-import { ReactiveCache } from "../../query/lib/ReactiveCache";
+import { ReactiveCache } from "@/query/lib/ReactiveCache";
 export declare class QueriesCache<KEY, VALUE> {
     private _cacheLifeTime;
     private readonly _cache;

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

@@ -1,5 +1,5 @@
 import { Subject } from "rxjs";
-import { OnCacheEntryAdded, OnQueryStarted } from "../../query/types";
+import { OnCacheEntryAdded, OnQueryStarted } from "@/query/types";
 type Options<ARGS, DATA> = {
     onCacheEntryAdded?: OnCacheEntryAdded<ARGS, DATA>;
     onQueryStarted?: OnQueryStarted<ARGS, DATA>;

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

@@ -1,5 +1,5 @@
-import { ReactiveCache } from "../../../query/lib/ReactiveCache";
-import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "../../../query/types";
+import { ReactiveCache } from "@/query/lib/ReactiveCache";
+import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "@/query/types";
 import { ResourceAgent } from "./ResourceAgent";
 export type CoreResourceQueryState<D extends ResourceDefinition> = {
     transactions: ResourceTransaction[] | null;

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

@@ -1,4 +1,4 @@
-import { ResourceAgentInstance, ResourceDefinition } 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;

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

@@ -1,6 +1,6 @@
-import { ResourceDefinition } from "../../../query/types";
+import { ResourceDefinition } from "@/query/types";
 import { CoreResourceQueryState, Resource } from "./Resource";
-import { ReadableSignalLike } from "../../../signals/types";
+import { ReadableSignalLike } from "@/signals/types";
 import { Observable, Subject } from "rxjs";
 import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
 export type DuplicatorOptions<D extends DuplicatorDefinition> = {
@@ -33,7 +33,7 @@ export declare class ResourceDuplicator<D extends DuplicatorDefinition> {
     createAgent: () => ResourceDuplicatorAgent<D>;
     /** @deprecated */
     d_init(args: D['ARGS_ITEM'][]): {
-        value$: import("../../../signals/types").ComputeFn<State<D>>;
+        value$: import("@/signals/types").ComputeFn<State<D>>;
     };
 }
 export declare class ComputedReactiveCache<T> {

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

@@ -1,4 +1,4 @@
-import { Signal, signalize } from "../../../signals";
+import { Signal, signalize } from "@/signals";
 import { finalize, ReplaySubject, share, Subject, takeUntil, timer } from "rxjs";
 import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
 export class ResourceDuplicator {
@@ -47,7 +47,6 @@ export class ResourceDuplicator {
             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);
@@ -87,7 +86,9 @@ export class ResourceDuplicator {
             fi.k++;
             releasedCaches.add(fi.cache);
         });
-        const queryCache = this._resource.createQueryCache(unreleasedArgs);
+        const queryCache = unreleasedArgs?.length > 0
+            ? this._resource.createQueryCache(unreleasedArgs)
+            : null;
         unreleasedArgs.forEach(arg => {
             const argKey = this._options.getArgKey(arg);
             let fi = this._fis.get(argKey);
@@ -101,9 +102,10 @@ export class ResourceDuplicator {
         });
         return {
             value$: Signal.compute(() => {
-                const itemsAcc = [
-                    queryCache.value$.get(),
-                ];
+                const itemsAcc = [];
+                if (queryCache) {
+                    itemsAcc.push(queryCache.value$.get());
+                }
                 for (const rc of releasedCaches) {
                     itemsAcc.push(rc.value$.get());
                 }

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

@@ -1,5 +1,5 @@
-import { ResourceAgentInstance } from "../../../query/types";
-import { ResourceDuplicator, DuplicatorDefinition } from "../../../query/core/Resource/ResourceDuplicator";
+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$;

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

@@ -1,4 +1,4 @@
-import { ResourceDefinition, ResourceRefInstanse, ResourceTransaction } from "../../../query/types";
+import { ResourceDefinition, ResourceRefInstanse, ResourceTransaction } from "@/query/types";
 import { Resource } from "./Resource";
 export declare class ResourceRef<D extends ResourceDefinition> implements ResourceRefInstanse<D> {
     private readonly _resource;

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

@@ -1,5 +1,5 @@
 import { Observable, Subject } from "rxjs";
-import { ReadableSignalLike } from "../../signals/types";
+import { ReadableSignalLike } from "@/signals/types";
 type Options<VALUE> = {
     /**
      * Начальное состояние кэша

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

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

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

@@ -1,4 +1,4 @@
-import { StateDevtoolsOptions } from "../../common/devtools";
+import { StateDevtoolsOptions } from "@/common/devtools";
 export declare const Devtools: {
     createState<T>(initialValue: T, optionsDry?: StateDevtoolsOptions): ((newState: T) => void) | null;
     readonly hasDevtools: boolean;

package/dist/signals/operators/signalize.d.ts

@@ -1,3 +1,3 @@
 import { Observable } from "rxjs";
-import { ReadableSignalFnLike } from "../../signals/types";
+import { ReadableSignalFnLike } from "@/signals/types";
 export declare function signalize<T>(observable: Observable<T>): ReadableSignalFnLike<T>;

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

@@ -1,8 +1,8 @@
-import { StateDevtoolsOptions } from "../../common/devtools";
-import { ComputeFn } from "../../signals/types";
+import { StateDevtoolsOptions } from "@/common/devtools";
+import { ComputeFn } from "@/signals/types";
 export declare class Computed<T> {
     private _computeFn;
-    private _ls;
+    private _state$;
     readonly obs: import("rxjs").Observable<T>;
     private _effect;
     /**

package/dist/signals/signals/Computed.js

@@ -4,7 +4,7 @@ import { Effect } from "./Effect";
 import { Signal } from "./Signal";
 export class Computed {
     _computeFn;
-    _ls;
+    _state$;
     obs;
     _effect = null;
     /**
@@ -18,8 +18,8 @@ export class Computed {
             ...(typeof options === 'string' ? { name: options } : options),
             _skipValues: [Computed._EMPTY],
         };
-        this._ls = new Signal(Computed._EMPTY, lsOptions);
-        this.obs = this._ls.obs.pipe(map((value) => {
+        this._state$ = Signal.state(Computed._EMPTY, lsOptions);
+        this.obs = this._state$.obs.pipe(map((value) => {
             if (value === Computed._EMPTY) {
                 return this._start();
             }
@@ -46,7 +46,7 @@ export class Computed {
         return this.peek();
     }
     peek() {
-        const v = this._ls.peek();
+        const v = this._state$.peek();
         if (v === Computed._EMPTY) {
             // Используем кеш для вычисления без создания подписки
             return this._computeCache.getOrCompute(this._computeFn);
@@ -58,10 +58,10 @@ export class Computed {
         this._effect = new Effect(() => {
             if (initialValue === Computed._EMPTY) {
                 initialValue = this._computeFn();
-                this._ls.set(initialValue);
+                this._state$.set(initialValue);
                 return;
             }
-            this._ls.set(this._computeFn());
+            this._state$.set(this._computeFn());
         });
         this._computeCache.clear();
         if (initialValue === Computed._EMPTY) {
@@ -74,7 +74,7 @@ export class Computed {
             this._effect.unsubscribe();
             this._effect = null;
         }
-        this._ls.set(Computed._EMPTY);
+        this._state$.set(Computed._EMPTY);
     }
     // === static ===
     static _EMPTY = Symbol('empty');

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

@@ -1,7 +1,7 @@
 import { ZodType } from "zod/v4";
 import { Observable } from "rxjs";
-import { SignalFn } from "../../signals/types";
-import { StateDevtoolsOptions } from "../../common/devtools";
+import { SignalFn } from "@/signals/types";
+import { StateDevtoolsOptions } from "@/common/devtools";
 type Options<T> = {
     zodSchema?: ZodType<T>;
     key: string;
@@ -15,7 +15,7 @@ type Options<T> = {
     devtoolsOptions?: StateDevtoolsOptions;
 };
 export declare class LocalSignal<T = string | null | number | undefined> {
-    private _signal;
+    private _state$;
     private _computed;
     private readonly _options;
     readonly obs: Observable<T>;

package/dist/signals/signals/LocalSignal.js

@@ -1,10 +1,10 @@
 import { z } from "zod/v4";
 import { signalize } from "../operators";
-import { Signal } from "./Signal";
 import { Computed } from "./Computed";
+import { State } from "@/signals/signals/State";
 const NONE = Symbol('NONE');
 export class LocalSignal {
-    _signal;
+    _state$;
     _computed;
     _options;
     obs;
@@ -13,10 +13,10 @@ export class LocalSignal {
         if (initialValue === NONE) {
             initialValue = options.defaultValue;
         }
-        this._signal = new Signal(initialValue, { isDisabled: true });
+        this._state$ = new State(initialValue, { isDisabled: true });
         const validatorSignal$ = options.validator$ && signalize(options.validator$);
         this._computed = new Computed(() => {
-            const value = this._signal.get();
+            const value = this._state$.get();
             if (validatorSignal$) {
                 const validator = validatorSignal$.get();
                 if (!validator(value)) {
@@ -33,7 +33,7 @@ export class LocalSignal {
     }
     set(value) {
         LocalSignal._setStorageValue(this._options, value);
-        this._signal.set(value);
+        this._state$.set(value);
     }
     peek() {
         return this._computed.peek();

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

@@ -1,18 +1,12 @@
-import { BehaviorSubject } from "rxjs";
-import { StateDevtoolsOptions } from "../../common/devtools";
-import { SignalFn } from "../../signals/types";
-import { Effect } from "../../signals";
-export declare class Signal<T> {
-    private readonly _stateDevtools;
-    private _rang;
-    protected readonly bs$: BehaviorSubject<T>;
-    readonly obs: import("rxjs").Observable<T>;
+import type { StateDevtoolsOptions } from "@/common/devtools";
+import { SignalFn } from "@/signals/types";
+import { Effect, State } from "@/signals/signals";
+export declare class Signal<T> extends State<T> {
+    /** @deprecated use `State` instead */
     constructor(initialValue: T, options?: StateDevtoolsOptions);
-    peek(): T;
-    set(value: T): void;
-    get(): T;
-    private static _finalizationRegistry;
+    /** @deprecated use `state` instead */
     static create<T>(initialValue: T, options?: StateDevtoolsOptions): SignalFn<T>;
-    static compute<T>(computeFn: () => T, options?: StateDevtoolsOptions): import("../../signals/types").ComputeFn<T>;
+    static state<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,56 +1,15 @@
-import { BehaviorSubject } from "rxjs";
-import { Computed, Effect } from "../../signals";
-import { Batcher, DependencyTracker, Devtools } from "../base";
-export class Signal {
-    _stateDevtools;
-    _rang = 0;
-    bs$;
-    obs;
+import { Computed, Effect, State } from "@/signals/signals";
+export class Signal extends State {
+    /** @deprecated use `State` instead */
     constructor(initialValue, options) {
-        this.bs$ = new BehaviorSubject(initialValue);
-        this.obs = this.bs$.asObservable();
-        this._stateDevtools = Devtools.createState(initialValue, {
-            base: Signal.name,
-            ...(typeof options === 'string' ? { name: options } : options)
-        });
-        if (this._stateDevtools) {
-            Signal._finalizationRegistry.register(this, this._stateDevtools);
-        }
+        super(initialValue, options);
     }
-    peek() {
-        return this.bs$.getValue();
-    }
-    set(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();
-    }
-    // === static ===
-    static _finalizationRegistry = new FinalizationRegistry((heldValue) => {
-        heldValue('$COMPLETED');
-    });
+    /** @deprecated use `state` instead */
     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;
+        return this.state(initialValue, options);
+    }
+    static state(initialValue, options) {
+        return State.create(initialValue, options);
     }
     static compute(computeFn, options) {
         return Computed.create(computeFn, options);

package/dist/signals/signals/State.d.ts

@@ -0,0 +1,15 @@
+import { BehaviorSubject } from "rxjs";
+import { StateDevtoolsOptions } from "@/common/devtools";
+import { SignalFn } from "@/signals/types";
+export declare class State<T> {
+    private readonly _stateDevtools;
+    private _rang;
+    protected readonly bs$: BehaviorSubject<T>;
+    readonly obs: import("rxjs").Observable<T>;
+    constructor(initialValue: T, options?: StateDevtoolsOptions);
+    peek(): T;
+    set(value: T): void;
+    get(): T;
+    private static _finalizationRegistry;
+    static create<T>(initialValue: T, options?: StateDevtoolsOptions): SignalFn<T>;
+}

package/dist/signals/signals/State.js

@@ -0,0 +1,54 @@
+import { BehaviorSubject } from "rxjs";
+import { Batcher, DependencyTracker, Devtools } from "../base";
+export class State {
+    _stateDevtools;
+    _rang = 0;
+    bs$;
+    obs;
+    constructor(initialValue, options) {
+        this.bs$ = new BehaviorSubject(initialValue);
+        this.obs = this.bs$.asObservable();
+        this._stateDevtools = Devtools.createState(initialValue, {
+            base: State.name,
+            ...(typeof options === 'string' ? { name: options } : options)
+        });
+        if (this._stateDevtools) {
+            State._finalizationRegistry.register(this, this._stateDevtools);
+        }
+    }
+    peek() {
+        return this.bs$.getValue();
+    }
+    set(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();
+    }
+    // === static ===
+    static _finalizationRegistry = new FinalizationRegistry((heldValue) => {
+        heldValue('$COMPLETED');
+    });
+    static create(initialValue, options) {
+        const ls = new State(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;
+    }
+}

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

@@ -1,4 +1,5 @@
+export * from './State';
 export * from './Computed';
 export * from './Effect';
-export * from './LocalSignal';
 export * from './Signal';
+export * from './LocalSignal';

package/dist/signals/signals/index.js

@@ -1,4 +1,6 @@
+// Порядок важен:
+export * from './State';
 export * from './Computed';
 export * from './Effect';
-export * from './LocalSignal';
 export * from './Signal';
+export * from './LocalSignal';

package/docs/signals/README.md

@@ -6,21 +6,21 @@ RxSignals — это реактивная система управления с
 
 ### Реактивность на основе значений
 
-Сигналы (`Signal`) хранят текущее состояние, а производные сущности (`Computed`, `Effect`) автоматически отслеживают зависимости,
-применяея кеширование на основе *значений*. Это приводит к тому, что в отличие от классического RxJS-подхода, 
+Сигналы (`State`) хранят текущее состояние, а производные сущности (`Computed`, `Effect`) автоматически отслеживают зависимости,
+применяя кеширование на основе *значений*. Это приводит к тому, что в отличие от классического RxJS-подхода,  
 где каждое `next()` — это событие, в RxSignals важен именно факт *изменения значения*.
 
-### Signal
+### State
 
-Базовый класс для создания реактивных сигналов с изменяемым состоянием.
+База для создания реактивных сигналов с изменяемым состоянием.
 
 **Пример использования:**
 
 ```typescript
 import { Signal } from '@fozy-labs/rx-toolkit';
 
-const name = Signal.create('John');
-const age = Signal.create(25);
+const name = Signal.state('John');
+const age = Signal.state(25);
 
 // Чтение значения (с отслеживанием зависимостей)
 console.log(name()); // "John"
@@ -53,8 +53,8 @@ subscription.unsubscribe();
 ```typescript
 import { Signal } from '@fozy-labs/rx-toolkit';
 
-const firstName = Signal.create('John');
-const lastName = Signal.create('Doe');
+const firstName = Signal.state('John');
+const lastName = Signal.state('Doe');
 
 const fullName = Signal.compute(() => `${firstName()} ${lastName()}`);
 
@@ -81,8 +81,8 @@ fullName.obs.subscribe(name => console.log(name));
 ```typescript
 import { Signal } from '@fozy-labs/rx-toolkit';
 
-const count = Signal.create(0);
-const message = Signal.create('Hello');
+const count = Signal.state(0);
+const message = Signal.state('Hello');
 
 const effect = Signal.effect(() => {
   // Выведет: "Hello: 0" при инициализации
@@ -117,13 +117,13 @@ const effect = Signal.effect(() => {
 RxSignals поддерживает как функциональный, так и классовый стили создания сигналов, позволяя выбрать подход в зависимости от предпочтений и архитектуры приложения.
 #### Функциональный стиль (рекомендуемый)
 
-Используйте статические методы `Signal.create`,`Signal.compute` и `Signal.effect` для создания сигналов. 
+Используйте статические методы `Signal.state`,`Signal.compute` и `Signal.effect` для создания сигналов. 
 Этот стиль лаконичен, похож на SolidJS и подходит для большинства случаев:
 
 ```tszz
 import { Signal } from '@fozy-labs/rx-toolkit';
 
-const count = Signal.create(0);
+const count = Signal.state(0);
 const doubled = Signal.compute(() => count() * 2);
 const logEffect = Signal.effect(() => console.log(doubled()));
 ```
@@ -135,9 +135,9 @@ const logEffect = Signal.effect(() => console.log(doubled()));
 учтите, что вызов `()` недоступен и нужно использовать `get()`:
 
 ```ts
-import { Signal, Computed, Effect } from '@fozy-labs/rx-toolkit';
+import { State, Computed, Effect } from '@fozy-labs/rx-toolkit';
 
-const count = new Signal(0);
+const count = new State(0);
 const doubled = new Computed(() => count.get() * 2);
 const logEffect = new Effect(() => console.log(doubled.get()));
 ```
@@ -227,8 +227,8 @@ RxSignals автоматически группирует множественн
 - Предсказуемый порядок выполнения эффектов
 
 ```typescript
-const a = Signal.create(1);
-const b = Signal.create((2);
+const a = Signal.state(1);
+const b = Signal.state(2);
 const sum = Signal.compute(() => a() + b());
 
 new Effect(() => {
@@ -251,7 +251,7 @@ Batcher.run(() => {
 import { filter, take, debounceTime } from 'rxjs';
 import { Signal, Computed, signalize } from '@fozy-labs/rx-toolkit';
 
-const clicks = Signal.create(0);
+const clicks = Signal.state(0);
 
 // Используем RxJS операторы
 const tenClicks$ = clicks.obs.pipe(
@@ -282,10 +282,10 @@ const doubled = Signal.compute(() => debouncedClicks$() * 2);
 import { Signal } from '@fozy-labs/rx-toolkit';
 
 // С именем для devtools
-const count$ = Signal.create(0, 'counter');
+const count$ = Signal.state(0, 'counter');
 
 // Или с расширенными опциями
-const user$ = Signal.create(null, {
+const user$ = Signal.state(null, {
     isDisabled: false, // Отключить отслеживание в devtools
 });
 ```

package/package.json

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