@ersbeth/picoflow 0.0.1 → 0.2.0

package/test/streamAsync.test.ts

@@ -0,0 +1,194 @@
+import { describe, expect, test, vi } from "vitest";
+import { effect, streamAsync } from "#package";
+
+describe("streamAsync", () => {
+    test("is updated (callback)", async () => {
+        const counter = {
+            count: 0,
+            callback: undefined as ((value: number) => void) | undefined,
+            increment() {
+                this.count++;
+                if (this.callback) {
+                    this.callback(this.count);
+                }
+            },
+        };
+
+        const $stream = streamAsync((set) => {
+            counter.callback = set;
+            return () => {
+                counter.callback = undefined;
+            };
+        });
+
+        const promise = $stream.get();
+
+        counter.increment();
+        expect(await promise).toBe(1);
+        expect(await $stream.get()).toBe(1);
+
+        counter.increment();
+        expect(await $stream.get()).toBe(2);
+    });
+
+    test("stream is updated (interval)", async () => {
+        vi.useFakeTimers();
+
+        const $stream = streamAsync<number>((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        });
+
+        const promise = $stream.get();
+
+        vi.advanceTimersToNextTimer();
+        expect(await promise).toBe(1);
+        expect(await $stream.get()).toBe(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(await $stream.get()).toBe(2);
+    });
+
+    test("get throws when stream is disposed", async () => {
+        vi.useFakeTimers();
+
+        const $stream = streamAsync((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        });
+
+        vi.advanceTimersToNextTimer();
+        expect(await $stream.get()).toBe(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(await $stream.get()).toBe(2);
+
+        $stream.dispose();
+        vi.advanceTimersToNextTimer();
+        expect(() => $stream.get()).toThrow("[PicoFlow] Primitive is disposed");
+    });
+});
+
+describe("effect", () => {
+    test("called when stream is updated", async () => {
+        vi.useFakeTimers();
+
+        const $stream = streamAsync((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        });
+
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($stream)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(new Promise(() => {}));
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toEqual(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(await effectFn.mock.calls[2][0]).toEqual(2);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(4);
+        expect(await effectFn.mock.calls[3][0]).toEqual(3);
+    });
+
+    test("NOT called when stream is updated with same value", async () => {
+        vi.useFakeTimers();
+
+        const $stream = streamAsync((set) => {
+            const interval = setInterval(() => {
+                set(5);
+            }, 1000);
+            return () => clearInterval(interval);
+        });
+
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($stream)));
+
+        expect(effectFn).toHaveBeenCalledTimes(1);
+        expect(effectFn).toHaveBeenLastCalledWith(new Promise(() => {}));
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toEqual(5);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toEqual(5);
+    });
+
+    test("NOT called when  disposed", async () => {
+        vi.useFakeTimers();
+
+        const $stream = streamAsync((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        });
+
+        const effectFn = vi.fn();
+        const $effect = effect((get) => effectFn(get($stream)));
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toEqual(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(await effectFn.mock.calls[2][0]).toEqual(2);
+
+        $effect.dispose();
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(await effectFn.mock.calls[2][0]).toEqual(2);
+    });
+
+    test("NOT called when stream is disposed", async () => {
+        vi.useFakeTimers();
+
+        const $stream = streamAsync((set) => {
+            let counter = 0;
+            const interval = setInterval(() => {
+                counter++;
+                set(counter);
+            }, 1000);
+            return () => clearInterval(interval);
+        });
+
+        const effectFn = vi.fn();
+        effect((get) => effectFn(get($stream)));
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(2);
+        expect(await effectFn.mock.calls[1][0]).toEqual(1);
+
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(await effectFn.mock.calls[2][0]).toEqual(2);
+
+        $stream.dispose();
+        vi.advanceTimersToNextTimer();
+        expect(effectFn).toHaveBeenCalledTimes(3);
+        expect(await effectFn.mock.calls[2][0]).toEqual(2);
+    });
+});

package/tsconfig.json

@@ -16,7 +16,9 @@
         "noUnusedParameters": true,
         "noFallthroughCasesInSwitch": true,
         "noImplicitOverride": true,
-        "noImplicitReturns": true
+        "noImplicitReturns": true,
+
+        "stripInternal": true
     },
     "include": ["./src/**/*", "./test/**/*"]
 }

package/api/doc/picoflow.flowdisposer.md

@@ -1,13 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [picoflow](./picoflow.md) &gt; [FlowDisposer](./picoflow.flowdisposer.md)
-
-## FlowDisposer type
-
-A function that disposes of a resource.
-
-**Signature:**
-
-```typescript
-export type FlowDisposer = () => void;
-```

package/api/doc/picoflow.flowsetter.md

@@ -1,13 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [picoflow](./picoflow.md) &gt; [FlowSetter](./picoflow.flowsetter.md)
-
-## FlowSetter type
-
-A function that sets a new value.
-
-**Signature:**
-
-```typescript
-export type FlowSetter<T> = (value: T) => void;
-```

package/api/doc/picoflow.flowstate._constructor_.md

@@ -1,49 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [picoflow](./picoflow.md) &gt; [FlowState](./picoflow.flowstate.md) &gt; [(constructor)](./picoflow.flowstate._constructor_.md)
-
-## FlowState.(constructor)
-
-Creates a new FlowState with the given initial value.
-
-**Signature:**
-
-```typescript
-constructor(value: T);
-```
-
-## Parameters
-
-<table><thead><tr><th>
-
-Parameter
-
-
-</th><th>
-
-Type
-
-
-</th><th>
-
-Description
-
-
-</th></tr></thead>
-<tbody><tr><td>
-
-value
-
-
-</td><td>
-
-T
-
-
-</td><td>
-
-The initial value for the state.
-
-
-</td></tr>
-</tbody></table>

package/api/doc/picoflow.flowstate.get.md

@@ -1,23 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [picoflow](./picoflow.md) &gt; [FlowState](./picoflow.flowstate.md) &gt; [get](./picoflow.flowstate.get.md)
-
-## FlowState.get() method
-
-Retrieves the current state value.
-
-**Signature:**
-
-```typescript
-get(): T;
-```
-**Returns:**
-
-T
-
-The current value of the state.
-
-## Exceptions
-
-Error if the state has been disposed.
-

package/api/doc/picoflow.flowupdater.md

@@ -1,19 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [picoflow](./picoflow.md) &gt; [FlowUpdater](./picoflow.flowupdater.md)
-
-## FlowUpdater type
-
-A function that performs updates on a stream.
-
-**Signature:**
-
-```typescript
-export type FlowUpdater<T> = (set: FlowSetter<T>) => FlowDisposer;
-```
-**References:** [FlowSetter](./picoflow.flowsetter.md)<!-- -->, [FlowDisposer](./picoflow.flowdisposer.md)
-
-## Remarks
-
-The updater receives a setter function that can be used to update the stream's value. It should return a disposer function to clean up any resources or subscriptions.
-

package/api/picoflow.api.md

@@ -1,145 +0,0 @@
-## API Report File for "picoflow"
-
-> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
-
-```ts
-
-// @public
-export function derivation<T>(fn: (get: FlowGetter, watch: FlowWatcher) => T): FlowDerivation<T>;
-
-// @public
-export function effect(fn: (get: FlowGetter, watch: FlowWatcher) => void): FlowEffect;
-
-// @public
-export class FlowDerivation<T> extends FlowObservable<T> {
-    constructor(compute: (get: FlowGetter, watch: FlowWatcher) => T);
-    // @internal
-    _exec(): void;
-    get(): T;
-    // @internal
-    _notify(): void;
-    // @internal
-    _watch(): void;
-}
-
-// @public
-export type FlowDisposer = () => void;
-
-// @public
-export class FlowEffect {
-    constructor(apply: (get: FlowGetter, watch: FlowWatcher) => void);
-    dispose(): void;
-    get disposed(): boolean;
-    // @internal
-    _exec(): void;
-    // @internal
-    _registerDependency(dependency: FlowSignal): void;
-    // @internal
-    _unregisterDependency(dependency: FlowSignal): void;
-}
-
-// @public
-export type FlowGetter = <T>(observable: FlowObservable<T>) => T;
-
-// @public
-export class FlowMap<K, V> extends FlowState<Map<K, V>> {
-    $lastDeleted: FlowState<{
-        key?: K;
-        value?: V;
-    }>;
-    $lastSet: FlowState<{
-        key?: K;
-        value?: V;
-    }>;
-    delete(key: K): void;
-    setAt(key: K, value: V): void;
-}
-
-// @public
-export abstract class FlowObservable<T> extends FlowSignal {
-    abstract get(): T;
-    // @internal
-    _getFrom(listener: FlowObservable<unknown> | FlowEffect): T;
-    // @internal
-    protected _value: T;
-}
-
-// @public
-export class FlowResource<T> extends FlowObservable<T> {
-    constructor(fetch: () => Promise<T>, initial: T);
-    fetch(): Promise<void>;
-    get(): T;
-}
-
-// @public
-export type FlowSetter<T> = (value: T) => void;
-
-// @public
-export class FlowSignal {
-    // @internal (undocumented)
-    protected _dependencies: Set<FlowSignal>;
-    dispose(): void;
-    get disposed(): boolean;
-    // @internal (undocumented)
-    protected _disposed: boolean;
-    // @internal (undocumented)
-    protected _effects: Set<FlowEffect>;
-    // @internal (undocumented)
-    protected _listeners: Set<FlowSignal>;
-    // @internal
-    _notify(): void;
-    // @internal
-    _registerDependency(dependency: FlowSignal): void;
-    // @internal
-    _registerEffect(effect: FlowEffect): void;
-    // @internal
-    _registerListener(signal: FlowSignal): void;
-    trigger(): void;
-    // @internal
-    _unregisterDependency(dependency: FlowSignal): void;
-    // @internal
-    _unregisterEffect(effect: FlowEffect): void;
-    // @internal
-    _unregisterListener(signal: FlowSignal): void;
-    // @internal
-    _watch(): void;
-    // @internal
-    _watchFrom(listener: FlowSignal | FlowEffect): void;
-}
-
-// @public
-export class FlowState<T> extends FlowObservable<T> {
-    constructor(value: T);
-    get(): T;
-    set(value: T): void;
-}
-
-// @public
-export class FlowStream<T> extends FlowObservable<T> {
-    constructor(updater: FlowUpdater<T>, initial: T);
-    dispose(): void;
-    get(): T;
-}
-
-// @public
-export type FlowUpdater<T> = (set: FlowSetter<T>) => FlowDisposer;
-
-// @public
-export type FlowWatcher = (signal: FlowSignal) => void;
-
-// @public
-export function map<K extends string | number | symbol, V>(initial?: Record<K, V>): FlowMap<K, V>;
-
-// @public
-export function resource<T>(fn: () => Promise<T>, initial: T): FlowResource<T>;
-
-// @public
-export function signal(): FlowSignal;
-
-// @public
-export function state<T>(value: T): FlowState<T>;
-
-// @public
-export function stream<T>(updater: (set: (value: T) => void) => () => void, initial: T): FlowStream<T>;
-
-```

package/dist/types/derivation.d.ts

@@ -1,58 +0,0 @@
-import { FlowGetter, FlowObservable } from './observable';
-import { FlowWatcher } from './signal';
-/**
- * Represents a reactive derivation whose value is computed based on other reactive signals.
- * @remarks
- * A FlowDerivation automatically tracks its dependencies and recomputes its value when needed.
- * @typeparam T - The type of the computed value.
- * @public
- */
-export declare class FlowDerivation<T> extends FlowObservable<T> {
-    /**
-     * Creates a new FlowDerivation.
-     * @param compute - A function that computes the derived value. It is provided with a getter
-     * and a watcher function to access observables and signals dependencies.
-     * @public
-     */
-    constructor(compute: (get: FlowGetter, watch: FlowWatcher) => T);
-    /**
-     * Gets the current derived value.
-     * @returns The current computed value.
-     * @remarks
-     * This method ensures that the derivation is up-to-date before returning the value.
-     * @public
-     */
-    get(): T;
-    /** @internal */
-    private _initialized;
-    /** @internal */
-    private _dirty;
-    /** @internal */
-    private _trackedGet;
-    /** @internal */
-    private _trackedWatch;
-    /** @internal */
-    private _untrackedGet;
-    /** @internal */
-    private _untrackedWatch;
-    /** @internal */
-    private _trackedExec;
-    /** @internal */
-    private _untrackedExec;
-    /**
-     * @internal
-     * Executes the compute function if necessary to update the derived value.
-     */
-    _exec(): void;
-    /**
-     * @internal
-     * Marks the derivation as dirty and notifies downstream dependencies.
-     */
-    _notify(): void;
-    /**
-     * @internal
-     * Ensures that the derivation is up-to-date when it is watched.
-     */
-    _watch(): void;
-}
-//# sourceMappingURL=derivation.d.ts.map

package/dist/types/derivation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../src/derivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;GAMG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAEpD;;;;;OAKG;gBACS,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC;IAM/D;;;;;;OAMG;IACI,GAAG,IAAI,CAAC;IAOf,gBAAgB;IAChB,OAAO,CAAC,YAAY,CAAS;IAE7B,gBAAgB;IAChB,OAAO,CAAC,MAAM,CAAQ;IAEtB,gBAAgB;IAChB,OAAO,CAAC,WAAW,CAAyD;IAE5E,gBAAgB;IAChB,OAAO,CAAC,aAAa,CAAoD;IAEzE,gBAAgB;IAChB,OAAO,CAAC,aAAa,CAAgD;IAErE,gBAAgB;IAChB,OAAO,CAAC,eAAe,CAA4C;IAEnE,gBAAgB;IAChB,OAAO,CAAC,YAAY,CAAU;IAE9B,gBAAgB;IAChB,OAAO,CAAC,cAAc,CAAU;IAEhC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAab;;;OAGG;IACM,OAAO,IAAI,IAAI;IAKxB;;;OAGG;IACM,MAAM,IAAI,IAAI;CAG1B"}

package/dist/types/effect.d.ts

@@ -1,108 +0,0 @@
-import { FlowGetter } from './observable';
-import { FlowSignal, FlowWatcher } from './signal';
-/**
- * Represents a reactive effect that executes a side‐effect function
- * based on its tracked dependencies.
- *
- * @remarks
- * A FlowEffect runs an apply function to perform side effects. The apply function
- * is executed in two modes:
- * Initially, in a tracked mode to register dependencies.
- * Subsequently, in an untracked mode to only re-execute the effect .
- *
- * @public
- */
-export declare class FlowEffect {
-    /**
-     * Creates a new FlowEffect.
-     *
-     * @param apply - A function that performs the side effect. It receives a getter and a watcher
-     * function to access and register dependencies on reactive observables and signals.
-     *
-     * @public
-     */
-    constructor(apply: (get: FlowGetter, watch: FlowWatcher) => void);
-    /**
-     * Disposes the effect, unregistering all its dependencies.
-     *
-     * @remarks
-     * After disposal, the effect should no longer be used. Calling this method on an already
-     * disposed effect will throw an error.
-     *
-     * @public
-     */
-    dispose(): void;
-    /**
-     * Indicates whether this effect has been disposed.
-     *
-     * @returns A boolean value indicating if the effect is disposed.
-     *
-     * @public
-     */
-    get disposed(): boolean;
-    /**
-     * @internal
-     */
-    private _disposed;
-    /**
-     * @internal
-     */
-    private _initialized;
-    /**
-     * @internal
-     */
-    private _dependencies;
-    /**
-     * @internal
-     * A tracked getter that registers a dependency when accessing an observable.
-     */
-    private _trackedGet;
-    /**
-     * @internal
-     * A tracked watcher that registers a dependency when watching a signal.
-     */
-    private _trackedWatch;
-    /**
-     * @internal
-     * An untracked getter that simply retrieves the current value from an observable.
-     */
-    private _untrackedGet;
-    /**
-     * @internal
-     * An untracked watcher that calls the default watch on a signal.
-     */
-    private _untrackedWatch;
-    /**
-     * @internal
-     * Execution function used during initialization (tracked mode).
-     */
-    private _trackedExec;
-    /**
-     * @internal
-     * Execution function used after initialization (untracked mode).
-     */
-    private _untrackedExec;
-    /**
-     * @internal
-     * Executes the effect. If the effect has not been initialized, it runs in tracked mode;
-     * otherwise, it runs in untracked mode.
-     *
-     * @throws Error if the effect has been disposed.
-     */
-    _exec(): void;
-    /**
-     * @internal
-     * Registers a dependency on the given signal.
-     *
-     * @param dependency - The FlowSignal to register as a dependency.
-     */
-    _registerDependency(dependency: FlowSignal): void;
-    /**
-     * @internal
-     * Unregisters the given dependency.
-     *
-     * @param dependency - The FlowSignal to unregister.
-     */
-    _unregisterDependency(dependency: FlowSignal): void;
-}
-//# sourceMappingURL=effect.d.ts.map

package/dist/types/effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IAGnB;;;;;;;OAOG;gBACS,KAAK,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI;IAMhE;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAQtB;;;;;;OAMG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAID;;OAEG;IACH,OAAO,CAAC,SAAS,CAAS;IAE1B;;OAEG;IACH,OAAO,CAAC,YAAY,CAAS;IAE7B;;OAEG;IACH,OAAO,CAAC,aAAa,CAAyB;IAE9C;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAyD;IAE5E;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAoD;IAEzE;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAgD;IAErE;;;OAGG;IACH,OAAO,CAAC,eAAe,CAA4C;IAEnE;;;OAGG;IACH,OAAO,CAAC,YAAY,CAAa;IAEjC;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAa;IAEnC;;;;;;OAMG;IACH,KAAK,IAAI,IAAI;IASb;;;;;OAKG;IACH,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAKjD;;;;;OAKG;IACH,qBAAqB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;CAItD"}

package/dist/types/map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEnD;;;;;;;;OAQG;IACI,QAAQ,EAAE,SAAS,CAAC;QAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,CAAA;KAAE,CAAC,CAAqB;IAEvE;;;;;;;;OAQG;IACI,YAAY,EAAE,SAAS,CAAC;QAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,CAAA;KAAE,CAAC,CAAqB;IAE3E;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAOpC;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;CAO9B"}

package/dist/types/observable.d.ts

@@ -1,40 +0,0 @@
-import { FlowEffect } from './effect';
-import { FlowSignal } from './signal';
-/**
- * A function for retrieving the current value from a FlowObservable.
- * @typeparam T - The type of the value held by the observable.
- * @param atom - The FlowObservable from which to get the value.
- * @returns The current value of the observable.
- * @public
- */
-export type FlowGetter = <T>(observable: FlowObservable<T>) => T;
-/**
- * Represents a reactive observable that carries a value.
- * @typeparam T - The type of the value held by the observable.
- * @remarks
- * A FlowObservable extends the basic FlowSignal to store a value. Subclasses must
- * implement the abstract {@link FlowObservable.get} method to return the current value.
- * @public
- */
-export declare abstract class FlowObservable<T> extends FlowSignal {
-    /**
-     * Retrieves the current value of the observable.
-     * @returns The current value.
-     * @public
-     */
-    abstract get(): T;
-    /**
-     * @internal
-     * Internal storage for the observable's value.
-     */
-    protected _value: T;
-    /**
-     * @internal
-     * Retrieves the current value from the observable and registers a dependency
-     * from the provided listener.
-     * @param listener - The FlowObservable or FlowEffect that is accessing this observable.
-     * @returns The current value, as returned by {@link FlowObservable.get}.
-     */
-    _getFrom(listener: FlowObservable<unknown> | FlowEffect): T;
-}
-//# sourceMappingURL=observable.d.ts.map