@fozy-labs/rx-toolkit 0.5.3-rc.0 → 0.5.3-rc.2

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

@@ -1,19 +1,4 @@
-import { OperationAgentInstanse, OperationDefinition } from "../../../query/types";
-import type { Operation } from "./Operation";
-export declare class OperationAgent<D extends OperationDefinition> implements OperationAgentInstanse<D> {
-    private _operation;
-    private _operations$;
-    state$: import("../../../signals/types").ComputeFn<{
-        isLoading: boolean;
-        isDone: boolean;
-        isSuccess: boolean;
-        isError: boolean;
-        error: {} | undefined;
-        data: NonNullable<import("../../../query/types").FallbackOnNever<D["Selected"], D["Result"]>> | undefined;
-        args: D["Args"];
-    }>;
-    constructor(_operation: Operation<D>);
-    private _next;
-    initiate(args: D["Args"]): void;
-    createAgent(): OperationAgentInstanse<D>;
-}
+/**
+ * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
+ */
+export { CommandAgent as OperationAgent } from '../Command/CommandAgent';

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

@@ -1,54 +1,4 @@
-import { Computed, Signal } from "../../../signals";
-export class OperationAgent {
-    _operation;
-    _operations$ = Signal.create({
-        current$: null,
-    }, { isDisabled: true });
-    state$ = Computed.create(() => {
-        const operations = this._operations$.get();
-        const currState = operations.current$?.value$.get();
-        // Нет текущего состояния — дефолт
-        if (!currState) {
-            return {
-                isLoading: false,
-                isDone: false,
-                isSuccess: false,
-                isError: false,
-                error: undefined,
-                data: undefined,
-                args: undefined,
-            };
-        }
-        return {
-            isLoading: currState.isLoading,
-            isDone: currState.isDone,
-            isSuccess: currState.isSuccess,
-            isError: currState.isError,
-            error: currState.error ?? undefined,
-            data: currState.data ?? undefined,
-            args: currState.arg,
-        };
-    }, { isDisabled: true });
-    constructor(_operation) {
-        this._operation = _operation;
-    }
-    _next(newCache) {
-        this._operations$.set({
-            current$: newCache,
-        });
-    }
-    initiate(args) {
-        const cache = this._operation.getQueryCache(args);
-        if (!cache) {
-            const newCache = this._operation.initiate(args);
-            this._next(newCache);
-            return;
-        }
-        // Всегда запускаем операцию заново, так как операции обычно не кэшируются как ресурсы
-        const newCache = this._operation.initiate(args, { cache });
-        this._next(newCache);
-    }
-    createAgent() {
-        return new OperationAgent(this._operation);
-    }
-}
+/**
+ * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
+ */
+export { CommandAgent as OperationAgent } from '../Command/CommandAgent';

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

@@ -1,7 +1,7 @@
 import { Computed, Signal } from "../../../signals";
 export class ResourceAgent {
     _resource;
-    _resources$ = Signal.create({
+    _resources$ = Signal.state({
         previous$: null,
         current$: null,
     }, { isDisabled: true });

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

@@ -1,7 +1,7 @@
 import { Computed, Signal } from "../../../signals";
 export class ResourceDuplicatorAgent {
     _resource;
-    _resources$ = Signal.create({
+    _resources$ = Signal.state({
         previous$: null,
         current$: null,
     }, { isDisabled: true });

package/dist/query/index.d.ts

@@ -1,8 +1,10 @@
+export * from './api/createCommand';
+export * from './react/useCommandAgent';
 export * from './api/createResource';
-export * from './api/createOperation';
-export * from './api/resetAllQueriesCache';
 export * from './api/createResourceDuplicator';
+export * from './api/resetAllQueriesCache';
 export * from './SKIP_TOKEN';
 export * from './react/useResourceAgent';
 export * from './react/useResourceRef';
+export * from './api/createOperation';
 export * from './react/useOperationAgent';

package/dist/query/index.js

@@ -1,8 +1,13 @@
+// Command API
+export * from './api/createCommand';
+export * from './react/useCommandAgent';
+// Resource API
 export * from './api/createResource';
-export * from './api/createOperation';
-export * from './api/resetAllQueriesCache';
 export * from './api/createResourceDuplicator';
+export * from './api/resetAllQueriesCache';
 export * from './SKIP_TOKEN';
 export * from './react/useResourceAgent';
 export * from './react/useResourceRef';
+// Deprecated Operation API (backward compatibility)
+export * from './api/createOperation';
 export * from './react/useOperationAgent';

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

@@ -0,0 +1,24 @@
+import type { Prettify, CommandAgentInstance, CommandDefinition, CommandQueryState } from "../../query/types";
+type WithAgent<D extends CommandDefinition> = {
+    createAgent: () => CommandAgentInstance<D>;
+};
+type TriggerFn<D extends CommandDefinition> = (args: D['Args']) => Promise<D['Data']>;
+type Result<D extends CommandDefinition> = [TriggerFn<D>, Prettify<CommandQueryState<D>>];
+/**
+ * React hook для работы с командой (Command).
+ *
+ * Возвращает кортеж `[trigger, state]`:
+ * - `trigger(args)` — инициирует выполнение команды и возвращает Promise с результатом.
+ * - `state` — реактивное состояние выполнения команды.
+ *
+ * @example
+ * ```tsx
+ * const [updateUser, state] = useCommandAgent(api.updateUser);
+ *
+ * const handleSubmit = async () => {
+ *   const result = await updateUser({ id: 1, name: 'New Name' });
+ * };
+ * ```
+ */
+export declare function useCommandAgent<D extends CommandDefinition>(op: WithAgent<D>): Result<D>;
+export {};

package/dist/query/react/useCommandAgent.js

@@ -0,0 +1,39 @@
+import { useConstant, useEventHandler } from "../../common/react";
+import { useSignal } from "../../signals/react";
+/**
+ * React hook для работы с командой (Command).
+ *
+ * Возвращает кортеж `[trigger, state]`:
+ * - `trigger(args)` — инициирует выполнение команды и возвращает Promise с результатом.
+ * - `state` — реактивное состояние выполнения команды.
+ *
+ * @example
+ * ```tsx
+ * const [updateUser, state] = useCommandAgent(api.updateUser);
+ *
+ * const handleSubmit = async () => {
+ *   const result = await updateUser({ id: 1, name: 'New Name' });
+ * };
+ * ```
+ */
+export function useCommandAgent(op) {
+    const agent = useConstant(() => op.createAgent());
+    const state = useSignal(agent.state$);
+    const trigger = useEventHandler((args) => {
+        agent.initiate(args);
+        return new Promise((resolve, reject) => {
+            const sub = agent.state$.obs.subscribe((s) => {
+                if (s.isDone && !s.isLoading) {
+                    sub.unsubscribe();
+                    if (s.isSuccess) {
+                        resolve(s.data);
+                    }
+                    else {
+                        reject(s.error);
+                    }
+                }
+            });
+        });
+    });
+    return [trigger, state];
+}

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

@@ -1,8 +1,6 @@
-import type { Prettify, OperationAgentInstanse, OperationDefinition, OperationQueryState } from "../../query/types";
-type WithAgent<D extends OperationDefinition> = {
-    createAgent: () => OperationAgentInstanse<D>;
-};
-type TriggerFn<D extends OperationDefinition> = (args: D['Args']) => Promise<D['Data']>;
-type Result<D extends OperationDefinition> = [TriggerFn<D>, Prettify<OperationQueryState<D>>];
-export declare function useOperationAgent<D extends OperationDefinition>(op: WithAgent<D>): Result<D>;
-export {};
+import { useCommandAgent } from './useCommandAgent';
+/**
+ * @deprecated Use `useCommandAgent` instead. Will be removed in v0.6.0.
+ * @see useCommandAgent
+ */
+export declare const useOperationAgent: typeof useCommandAgent;

package/dist/query/react/useOperationAgent.js

@@ -1,23 +1,6 @@
-import { useConstant, useEventHandler } from "../../common/react";
-import { useSignal } from "../../signals/react";
-export function useOperationAgent(op) {
-    const agent = useConstant(() => op.createAgent());
-    const state = useSignal(agent.state$);
-    const trigger = useEventHandler((args) => {
-        agent.initiate(args);
-        return new Promise((resolve, reject) => {
-            const sub = agent.state$.obs.subscribe((s) => {
-                if (s.isDone && !s.isLoading) {
-                    sub.unsubscribe();
-                    if (s.isSuccess) {
-                        resolve(s.data);
-                    }
-                    else {
-                        reject(s.error);
-                    }
-                }
-            });
-        });
-    });
-    return [trigger, state];
-}
+import { useCommandAgent } from './useCommandAgent';
+/**
+ * @deprecated Use `useCommandAgent` instead. Will be removed in v0.6.0.
+ * @see useCommandAgent
+ */
+export const useOperationAgent = useCommandAgent;

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

@@ -0,0 +1,154 @@
+import { ReadableSignalLike } from "../../signals/types";
+import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
+import { ResourceDefinition, ResourceInstance } from "./Resource.types";
+/**
+ * Функция создания команды
+ */
+export type CommandCreateFn<ARGS, RESULT, SELECTED = never> = (options: CommandCreateOptions<CommandDefinition<ARGS, RESULT, SELECTED>>) => CommandInstance<CommandDefinition<ARGS, RESULT, SELECTED>>;
+/**
+ * Опции создания команды
+ */
+export type CommandCreateOptions<D extends CommandDefinition> = {
+    /** Функция селектора для преобразования результата команды */
+    select?: (data: D["Result"]) => D["Selected"];
+    /** Функция выполнения команды */
+    queryFn: (args: D["Args"]) => Promise<D["Result"]>;
+    /** Связанные ресурсы */
+    link?: (link: <RD extends ResourceDefinition>(options: LinkOptions<D, RD>) => void) => void;
+    /**
+     * Время жизни кеша в миллисекундах. По умолчанию 1_000 (1 секунда).
+     * Если указано false - кеш не удаляется автоматически.
+     */
+    cacheLifetime?: number | false;
+    /**
+     * Хук, вызываемый при добавлении нового элемента в кеш.
+     * Также позволяет отследить:
+     *  - когда данные были загружены (впервые)
+     *  - когда элемент был удален из кеша
+     */
+    onCacheEntryAdded?: OnCacheEntryAdded<D["Args"], D["Data"]>;
+    /**
+     * Хук, вызываемый при старте запроса.
+     * Также позволяет отследить:
+     * - завершение запроса с результатом или ошибкой
+     */
+    onQueryStarted?: OnQueryStarted<D["Args"], D["Result"]>;
+    /**
+     * Настройка отображения в devtools
+     */
+    devtoolsName?: string | false;
+};
+/**
+ * Настройки связи команды с ресурсом
+ */
+export type LinkOptions<D extends CommandDefinition, RD extends ResourceDefinition> = {
+    /**
+     * Целевой ресурс, с которым связывается команда
+     * @required
+     */
+    resource: ResourceInstance<RD>;
+    /**
+     * Функция для получения аргументов ресурса из аргументов команды.
+     * Используется для определения какой именно элемент в кэше ресурса нужно обновить
+     * @required
+     */
+    forwardArgs: (args: D["Args"]) => RD["Args"];
+    /**
+     * Флаг для инвалидации (очистки) кэша ресурса после выполнения команды.
+     * При true - кэш будет очищен и ресурс будет перезагружен при следующем обращении
+     * @optional @default false
+     */
+    invalidate?: boolean;
+    /**
+     * Флаг для блокировки ресурса во время выполнения команды.
+     * При true - ресурс будет заблокирован и не сможет выполнять новые запросы
+     * @optional @default false
+     */
+    lock?: boolean;
+    /**
+     * Функция для обновления кэша ресурса после успешного выполнения команды.
+     * Получает draft объект для мутации, аргументы команды и результат команды
+     * @optional
+     */
+    update?: (tools: {
+        /** Immer draft объект для мутации кэша ресурса */
+        draft: RD["Data"];
+        /** Аргументы, с которыми была вызвана команда */
+        args: D["Args"];
+        /** Результат выполнения команды */
+        data: D["Data"];
+    }) => void | RD["Data"] | Promise<RD["Data"]>;
+    /**
+     * Функция для оптимистичного обновления кэша ресурса ДО выполнения команды.
+     * Позволяет обновить UI немедленно, до получения ответа от сервера
+     * @optional
+     */
+    optimisticUpdate?: (tools: {
+        /** Immer draft объект для мутации кэша ресурса */
+        draft: RD["Data"];
+        /** Аргументы, с которыми была вызвана команда */
+        args: D["Args"];
+    }) => void | RD["Data"] | Promise<RD["Data"]>;
+    /**
+     * Функция для создания нового элемента в кэше ресурса.
+     * Используется когда команда создает новую сущность, которую нужно добавить в кэш
+     * @optional
+     */
+    create?: (tools: {
+        /** Аргументы, с которыми была вызвана команда */
+        args: D["Args"];
+        /** Результат выполнения команды */
+        data: D["Data"];
+    }) => RD["Data"] | Promise<RD["Data"]>;
+};
+/**
+ * Определение типов команды
+ */
+export type CommandDefinition<A = any, R = any, S = any> = {
+    Args: A;
+    Result: R;
+    Selected: S;
+    Data: FallbackOnNever<S, R>;
+};
+/**
+ * Экземпляр команды
+ */
+export type CommandInstance<D extends CommandDefinition> = {
+    /** Создает агента для выполнения команды */
+    createAgent(): CommandAgentInstance<D>;
+    /**
+     * Выполняет команду с указанными аргументами
+     * @deprecated
+     */
+    mutate: (args: D["Args"]) => Promise<D["Data"]>;
+};
+/**
+ * Агент для выполнения команды
+ */
+export type CommandAgentInstance<D extends CommandDefinition> = {
+    /** Observable состояния выполнения команды */
+    state$: ReadableSignalLike<CommandQueryState<D>>;
+    /** Инициирует выполнение команды с указанными аргументами */
+    initiate(args: D["Args"]): void;
+    /** Создает новый агент команды */
+    createAgent(): CommandAgentInstance<D>;
+};
+/**
+ * Состояние выполнения команды
+ */
+export type CommandQueryState<D extends CommandDefinition> = {
+    /** Выполняется ли команда в данный момент */
+    isLoading: boolean;
+    /** Завершена ли команда */
+    isDone: boolean;
+    /** Успешно ли завершена команда (false по умолчанию) */
+    isSuccess: boolean;
+    /** Произошла ли ошибка при выполнении команды (false по умолчанию) */
+    isError: boolean;
+    /** Оригинал ошибки, если есть */
+    error: unknown | undefined;
+    /** Результат выполнения команды */
+    data: D["Data"] | undefined;
+    /** Аргументы команды */
+    args: D["Args"];
+};

package/dist/query/types/Command.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,154 +1,13 @@
-import { ReadableSignalLike } from "../../signals/types";
-import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
-import { ResourceDefinition, ResourceInstance } from "./Resource.types";
-/**
- * Функция создания операции
- */
-export type OperationCreateFn<ARGS, RESULT, SELECTED = never> = (options: OperationCreateOptions<OperationDefinition<ARGS, RESULT, SELECTED>>) => OperationInstance<OperationDefinition<ARGS, RESULT, SELECTED>>;
-/**
- * Опции создания операции
- */
-export type OperationCreateOptions<D extends OperationDefinition> = {
-    /** Функция селектора для преобразования результата операции */
-    select?: (data: D["Result"]) => D["Selected"];
-    /** Функция выполнения операции */
-    queryFn: (args: D["Args"]) => Promise<D["Result"]>;
-    /** Связанные ресурсы */
-    link?: (link: <RD extends ResourceDefinition>(options: LinkOptions<D, RD>) => void) => void;
-    /**
-     * Время жизни кеша в миллисекундах. По умолчанию 1_000 (1 секунда).
-     * Если указано false - кеш не удаляется автоматически.
-     */
-    cacheLifetime?: number | false;
-    /**
-     * Хук, вызываемый при добавлении нового элемента в кеш.
-     * Также позволяет отследить:
-     *  - когда данные были загружены (впервые)
-     *  - когда элемент был удален из кеша
-     */
-    onCacheEntryAdded?: OnCacheEntryAdded<D["Args"], D["Data"]>;
-    /**
-     * Хук, вызываемый при старте запроса.
-     * Также позволяет отследить:
-     * - завершение запроса с результатом или ошибкой
-     */
-    onQueryStarted?: OnQueryStarted<D["Args"], D["Result"]>;
-    /**
-     * Настройка отображения в devtools
-     */
-    devtoolsName?: string | false;
-};
-/**
- * Настройки связи операции с ресурсом
- */
-export type LinkOptions<D extends OperationDefinition, RD extends ResourceDefinition> = {
-    /**
-     * Целевой ресурс, с которым связывается операция
-     * @required
-     */
-    resource: ResourceInstance<RD>;
-    /**
-     * Функция для получения аргументов ресурса из аргументов операции.
-     * Используется для определения какой именно элемент в кэше ресурса нужно обновить
-     * @required
-     */
-    forwardArgs: (args: D["Args"]) => RD["Args"];
-    /**
-     * Флаг для инвалидации (очистки) кэша ресурса после выполнения операции.
-     * При true - кэш будет очищен и ресурс будет перезагружен при следующем обращении
-     * @optional @default false
-     */
-    invalidate?: boolean;
-    /**
-     * Флаг для блокировки ресурса во время выполнения операции.
-     * При true - ресурс будет заблокирован и не сможет выполнять новые запросы
-     * @optional @default false
-     */
-    lock?: boolean;
-    /**
-     * Функция для обновления кэша ресурса после успешного выполнения операции.
-     * Получает draft объект для мутации, аргументы операции и результат операции
-     * @optional
-     */
-    update?: (tools: {
-        /** Immer draft объект для мутации кэша ресурса */
-        draft: RD["Data"];
-        /** Аргументы, с которыми была вызвана операция */
-        args: D["Args"];
-        /** Результат выполнения операции */
-        data: D["Data"];
-    }) => void | RD["Data"] | Promise<RD["Data"]>;
-    /**
-     * Функция для оптимистичного обновления кэша ресурса ДО выполнения операции.
-     * Позволяет обновить UI немедленно, до получения ответа от сервера
-     * @optional
-     */
-    optimisticUpdate?: (tools: {
-        /** Immer draft объект для мутации кэша ресурса */
-        draft: RD["Data"];
-        /** Аргументы, с которыми была вызвана операция */
-        args: D["Args"];
-    }) => void | RD["Data"] | Promise<RD["Data"]>;
-    /**
-     * Функция для создания нового элемента в кэше ресурса.
-     * Используется когда операция создает новую сущность, которую нужно добавить в кэш
-     * @optional
-     */
-    create?: (tools: {
-        /** Аргументы, с которыми была вызвана операция */
-        args: D["Args"];
-        /** Результат выполнения операции */
-        data: D["Data"];
-    }) => RD["Data"] | Promise<RD["Data"]>;
-};
-/**
- * Определение типов операции
- */
-export type OperationDefinition<A = any, R = any, S = any> = {
-    Args: A;
-    Result: R;
-    Selected: S;
-    Data: FallbackOnNever<S, R>;
-};
-/**
- * Экземпляр операции
- */
-export type OperationInstance<D extends OperationDefinition> = {
-    /** Создает агента для выполнения операции */
-    createAgent(): OperationAgentInstanse<D>;
-    /**
-     * Выполняет операцию с указанными аргументами
-     * @deprecated
-     */
-    mutate: (args: D["Args"]) => Promise<D["Data"]>;
-};
-/**
- * Агент для выполнения операции
- */
-export type OperationAgentInstanse<D extends OperationDefinition> = {
-    /** Observable состояния выполнения операции */
-    state$: ReadableSignalLike<OperationQueryState<D>>;
-    /** Инициирует выполнение операции с указанными аргументами */
-    initiate(args: D["Args"]): void;
-    /** Создает новый агент операции */
-    createAgent(): OperationAgentInstanse<D>;
-};
-/**
- * Состояние выполнения операции
- */
-export type OperationQueryState<D extends OperationDefinition> = {
-    /** Выполняется ли операция в данный момент */
-    isLoading: boolean;
-    /** Завершена ли операция */
-    isDone: boolean;
-    /** Успешно ли завершена операция (false по умолчанию) */
-    isSuccess: boolean;
-    /** Произошла ли ошибка при выполнении операции (false по умолчанию) */
-    isError: boolean;
-    /** Оригинал ошибки, если есть */
-    error: unknown | undefined;
-    /** Результат выполнения операции */
-    data: D["Data"] | undefined;
-    /** Аргументы операции */
-    args: D["Args"];
-};
+import { CommandCreateFn, CommandCreateOptions, CommandDefinition, CommandInstance, CommandAgentInstance, CommandQueryState } from './Command.types';
+/** @deprecated Use `CommandCreateFn` instead. Will be removed in v0.6.0. */
+export type OperationCreateFn<ARGS, RESULT, SELECTED = never> = CommandCreateFn<ARGS, RESULT, SELECTED>;
+/** @deprecated Use `CommandCreateOptions` instead. Will be removed in v0.6.0. */
+export type OperationCreateOptions<D extends CommandDefinition> = CommandCreateOptions<D>;
+/** @deprecated Use `CommandDefinition` instead. Will be removed in v0.6.0. */
+export type OperationDefinition<A = any, R = any, S = any> = CommandDefinition<A, R, S>;
+/** @deprecated Use `CommandInstance` instead. Will be removed in v0.6.0. */
+export type OperationInstance<D extends CommandDefinition> = CommandInstance<D>;
+/** @deprecated Use `CommandAgentInstance` instead. Will be removed in v0.6.0. */
+export type OperationAgentInstanse<D extends CommandDefinition> = CommandAgentInstance<D>;
+/** @deprecated Use `CommandQueryState` instead. Will be removed in v0.6.0. */
+export type OperationQueryState<D extends CommandDefinition> = CommandQueryState<D>;

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

@@ -1,3 +1,4 @@
-export * from './Operation.types';
+export * from './Command.types';
 export * from './Resource.types';
 export * from './shared.types';
+export * from './Operation.types';

package/dist/query/types/index.js

@@ -1,3 +1,5 @@
-export * from './Operation.types';
+export * from './Command.types';
 export * from './Resource.types';
 export * from './shared.types';
+// Deprecated Operation types (backward compatibility)
+export * from './Operation.types';

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

@@ -2,7 +2,7 @@ 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');