@ersbeth/picoflow 0.0.1 → 0.2.0

package/dist/types/advanced/array.d.ts

@@ -0,0 +1,116 @@
+import { FlowObservable, FlowState } from '../basic';
+/**
+ * Represents the actions that can be performed on a FlowArray.
+ * @public
+ */
+export type FlowArrayAction<T> = {
+    type: "set";
+    items: T[];
+} | {
+    type: "setItem";
+    index: number;
+    item: T;
+} | {
+    type: "push";
+    item: T;
+} | {
+    type: "pop";
+} | {
+    type: "unshift";
+    item: T;
+} | {
+    type: "shift";
+} | {
+    type: "splice";
+    start: number;
+    deleteCount: number;
+    items: T[];
+} | {
+    type: "clear";
+};
+/**
+ * Represents a reactive array.
+ * @public
+ */
+export declare class FlowArray<T> extends FlowObservable<T[]> {
+    /**
+     * Last action performed on the FlowArray.
+     * @public
+     */
+    $lastAction: FlowState<FlowArrayAction<T>>;
+    /**
+     * Creates an instance of FlowArray.
+     * @param value - Initial array value.
+     * @public
+     */
+    constructor(value?: T[]);
+    /**
+     * Gets the current length of the array.
+     * @returns The length of the array.
+     * @public
+     */
+    get length(): number;
+    /**
+     * Returns a copy of the internal array.
+     * @returns A copy of the array.
+     * @public
+     */
+    get(): T[];
+    /**
+     * Replaces the entire array with new items.
+     * @param items - The new array of items.
+     * @public
+     */
+    set(items: T[]): void;
+    /**
+     * Replaces an item at a specific index.
+     * @param index - The index of the item to replace.
+     * @param item - The new item.
+     * @public
+     */
+    setItem(index: number, item: T): void;
+    /**
+     * Appends an item to the end of the array.
+     * @param item - The item to append.
+     * @public
+     */
+    push(item: T): void;
+    /**
+     * Removes the last item from the array.
+     * @public
+     */
+    pop(): void;
+    /**
+     * Inserts an item at the beginning of the array.
+     * @param item - The item to insert.
+     * @public
+     */
+    unshift(item: T): void;
+    /**
+     * Removes the first item from the array.
+     * @public
+     */
+    shift(): void;
+    /**
+     * Changes the content of the array.
+     * @param start - The starting index.
+     * @param deleteCount - Number of items to remove.
+     * @param newItems - New items to add.
+     * @public
+     */
+    splice(start: number, deleteCount: number, ...newItems: T[]): void;
+    /**
+     * Clears all items from the array.
+     * @public
+     */
+    clear(): void;
+    /**
+     * Disposes the FlowArray and its items.
+     * @param options - Disposal options.
+     * @public
+     */
+    dispose(options?: {
+        self: boolean;
+    }): void;
+}
+//# sourceMappingURL=array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../src/advanced/array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAI1D;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IACvB;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,CAAC,EAAE,CAAC;CACd,GACC;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,CAAC,CAAC;CACX,GACC;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,CAAC;CACX,GACC;IACE,IAAI,EAAE,KAAK,CAAC;CACf,GACC;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,CAAC,CAAC;CACX,GACC;IACE,IAAI,EAAE,OAAO,CAAC;CACjB,GACC;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,CAAC,EAAE,CAAC;CACd,GACC;IACE,IAAI,EAAE,OAAO,CAAC;CACjB,CAAC;AAEN;;;GAGG;AACH,qBAAa,SAAS,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,EAAE,CAAC;IACjD;;;OAGG;IACH,WAAW,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAE3C;;;;OAIG;gBACS,KAAK,GAAE,CAAC,EAAO;IAS3B;;;;OAIG;IACH,IAAI,MAAM,IAAI,MAAM,CAGnB;IAED;;;;OAIG;IACH,GAAG,IAAI,CAAC,EAAE;IAKV;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAUrB;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAUrC;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAOnB;;;OAGG;IACH,GAAG,IAAI,IAAI;IAUX;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAOtB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAUb;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,CAAC,EAAE,GAAG,IAAI;IAelE;;;OAGG;IACH,KAAK,IAAI,IAAI;IAWb;;;;OAIG;IACM,OAAO,CAAC,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;CAWtD"}

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

@@ -0,0 +1,9 @@
+export { FlowMap } from './map';
+export { FlowStream } from './stream';
+export { FlowStreamAsync } from './streamAsync';
+export { FlowResource } from './resource';
+export { FlowResourceAsync } from './resourceAsync';
+export type { FlowStreamUpdater, FlowStreamDisposer, FlowStreamSetter, } from './stream';
+export { FlowArray } from './array';
+export type { FlowArrayAction } from './array';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/advanced/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EACR,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,GACnB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/dist/types/{map.d.ts → advanced/map.d.ts}

@@ -1,17 +1,16 @@
-import { FlowState } from './state';
+import { FlowState } from '../basic/';
 /**
- * Represents a reactive map of states that extends {@link FlowState} for a Map of key/value pairs.
+ * Represents a reactive map of states extending {@link FlowState} for a Map of key/value pairs.
  *
  * @remarks
  * FlowMap wraps a native Map and provides reactive signals for fine-grained tracking
  * of updates to the map. In addition to the reactive capabilities inherited from FlowState,
- * it exposes two public signals:
+ * it exposes two reactive signals:
  *
- * **$lastSet**: A FlowState that holds the most recent key-value pair that was set.
+ * • $lastSet: Holds the most recent key-value pair that was set.
+ * • $lastDeleted: Holds the most recent key-value pair that was deleted.
  *
- * **$lastDeleted**: A FlowState that holds the most recent key-value pair that was deleted.
- *
- * Use {@link FlowMap.setAt} to set a key-value pair and {@link FlowMap.delete} to remove a key.
+ * Use {@link FlowMap.setAt} to add or update a key-value pair and {@link FlowMap.delete} to remove a key.
  *
  * @typeparam K - The type of the map keys.
  * @typeparam V - The type of the map values.
@@ -50,10 +49,11 @@ export declare class FlowMap<K, V> extends FlowState<Map<K, V>> {
      *
      * @param key - The key at which to set the value.
      * @param value - The value to set.
+     * @throws If the FlowMap instance is disposed.
      *
      * @remarks
-     * This method updates the internal map with the given key and value, emits the new
-     * key-value pair via {@link FlowMap.$lastSet}, and notifies subscribers of the change.
+     * Updates the internal map, emits the key-value pair via {@link FlowMap.$lastSet},
+     * and notifies all subscribers of the change.
      *
      * @public
      */
@@ -62,11 +62,11 @@ export declare class FlowMap<K, V> extends FlowState<Map<K, V>> {
      * Deletes the value at the specified key from the underlying map.
      *
      * @param key - The key to delete.
+     * @throws If the FlowMap instance is disposed.
      *
      * @remarks
-     * This method removes the key from the internal map, emits the deleted key and its
-     * corresponding value via {@link FlowMap.$lastDeleted}, and notifies subscribers
-     * of the change.
+     * Removes the key from the internal map, emits the deleted key and its value via {@link FlowMap.$lastDeleted},
+     * and notifies all subscribers of the change.
      *
      * @public
      */

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../../src/advanced/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD;;;;;;;;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;;;;;;;;;;;;OAYG;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/advanced/resource.d.ts

@@ -0,0 +1,39 @@
+import { FlowObservable } from '../basic';
+/**
+ * Represents a reactive resource that asynchronously fetches its value.
+ *
+ * @remarks A FlowResource extends FlowObservable and encapsulates an asynchronous fetch function.
+ * It is used to retrieve and update its value asynchronously. When the fetch is executed,
+ * if the new value differs from the current value, the resource is updated and its subscribers
+ * are notified.
+ *
+ * @public
+ */
+export declare class FlowResource<T> extends FlowObservable<T | undefined> {
+    /**
+     * Creates a new FlowResource.
+     * @param fetch - An asynchronous function that retrieves the resource's value.
+     *
+     * @public
+     */
+    constructor(fetch: () => Promise<T>);
+    /**
+     * Retrieves the current resource value.
+     * @returns The current value, or undefined if the resource has not been fetched yet.
+     * @throws Error if the resource is disposed.
+     * @public
+     */
+    get(): T | undefined;
+    /**
+     * Asynchronously fetches a new value for the resource.
+     * @remarks
+     * Executes the internal fetch function. If the fetched value differs from the current one,
+     * updates the resource's value and notifies subscribers.
+     * @returns A Promise that resolves when the fetch operation is complete.
+     * @throws Error if the resource is disposed.
+     * @public
+     */
+    fetch(): Promise<void>;
+    private _fetch;
+}
+//# sourceMappingURL=resource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/advanced/resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;GASG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,GAAG,SAAS,CAAC;IAC9D;;;;;OAKG;gBACS,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAKnC;;;;;OAKG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAK3B;;;;;;;;OAQG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUnC,OAAO,CAAC,MAAM,CAAmB;CACpC"}

package/dist/types/{resource.d.ts → advanced/resourceAsync.d.ts}

@@ -1,4 +1,4 @@
-import { FlowObservable } from './observable';
+import { FlowObservable } from '../basic/';
 /**
  * Represents a reactive resource that asynchronously fetches its value.
  *
@@ -12,21 +12,20 @@ import { FlowObservable } from './observable';
  *
  * @public
  */
-export declare class FlowResource<T> extends FlowObservable<T> {
+export declare class FlowResourceAsync<T> extends FlowObservable<Promise<T>> {
     /**
      * Creates a new FlowResource.
      * @param fetch - An asynchronous function that retrieves the resource's value.
-     * @param initial - The initial value of the resource.
      * @public
      */
-    constructor(fetch: () => Promise<T>, initial: T);
+    constructor(fetch: () => Promise<T>);
     /**
      * Retrieves the current resource value.
-     * @returns The current value.
+     * @returns The current value, or undefined if the resource has not been fetched yet.
      * @throws Error if the resource is disposed.
      * @public
      */
-    get(): T;
+    get(): Promise<T>;
     /**
      * Asynchronously fetches a new value for the resource.
      * @remarks
@@ -37,10 +36,6 @@ export declare class FlowResource<T> extends FlowObservable<T> {
      * @public
      */
     fetch(): Promise<void>;
-    /**
-     * @internal
-     * The asynchronous function used to fetch the resource value.
-     */
     private _fetch;
 }
-//# sourceMappingURL=resource.d.ts.map
+//# sourceMappingURL=resourceAsync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resourceAsync.d.ts","sourceRoot":"","sources":["../../../src/advanced/resourceAsync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAChE;;;;OAIG;gBACS,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAKnC;;;;;OAKG;IACI,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;IAMxB;;;;;;;;OAQG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQnC,OAAO,CAAC,MAAM,CAAmB;CACpC"}

package/dist/types/advanced/stream.d.ts

@@ -0,0 +1,59 @@
+import { FlowObservable } from '../basic/';
+/**
+ * A function type that sets a new value for the reactive stream.
+ * @typeparam T - The type of the value.
+ * @public
+ */
+export type FlowStreamSetter<T> = (value: T) => void;
+/**
+ * A function type that disposes of a resource.
+ * @public
+ */
+export type FlowStreamDisposer = () => void;
+/**
+ * A function type that updates a stream and returns a disposer for cleanup.
+ * @remarks
+ * The updater receives a setter function to update the stream's value.
+ * It should return a disposer function to release any resources or subscriptions.
+ * @typeparam T - The type of the stream value.
+ * @public
+ */
+export type FlowStreamUpdater<T> = (set: FlowStreamSetter<T>) => FlowStreamDisposer;
+/**
+ * Represents a reactive stream that updates its value based on an updater function.
+ *
+ * @remarks
+ * FlowStream extends FlowObservable to encapsulate an update mechanism provided by an external updater function.
+ * The updater is invoked during construction with a setter, and it returns a disposer to be called upon disposal.
+ * Note: The stream's current value may be undefined until explicitly set.
+ *
+ * @typeparam T - The type of the stream's value.
+ * @public
+ */
+export declare class FlowStream<T> extends FlowObservable<T | undefined> {
+    /**
+     * Creates a new FlowStream.
+     * @param updater - A function that receives a setter to update the stream's value.
+     * It should return a disposer function that will be called upon disposal.
+     * @public
+     */
+    constructor(updater: FlowStreamUpdater<T>);
+    /**
+     * Retrieves the current value of the stream.
+     * @returns The current value, or undefined if no value has been set yet.
+     * @throws Error if the stream is disposed.
+     * @public
+     */
+    get(): T | undefined;
+    /**
+     * Disposes the stream, releasing all resources.
+     * @remarks
+     * In addition to disposing the underlying observable, this method calls the disposer
+     * returned by the updater.
+     * @public
+     */
+    dispose(): void;
+    private _disposer;
+    private _set;
+}
+//# sourceMappingURL=stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/advanced/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAErD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAC/B,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACvB,kBAAkB,CAAC;AAExB;;;;;;;;;;GAUG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,GAAG,SAAS,CAAC;IAC5D;;;;;OAKG;gBACS,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAOzC;;;;;OAKG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAK3B;;;;;;OAMG;IACa,OAAO,IAAI,IAAI;IAO/B,OAAO,CAAC,SAAS,CAAqB;IAEtC,OAAO,CAAC,IAAI;CAOf"}

package/dist/types/advanced/streamAsync.d.ts

@@ -0,0 +1,43 @@
+import { FlowObservable } from '../basic';
+import { FlowStreamUpdater } from './stream';
+/**
+ * Represents an asynchronous reactive stream that updates its value based on an updater function.
+ *
+ * @remarks
+ * A FlowStreamAsync extends FlowObservable and encapsulates a mechanism for asynchronously updating its value.
+ * The updater is invoked during construction with a setter, and its returned disposer is called upon disposal.
+ * Note: The stream's current value may be undefined until it is set.
+ *
+ * @typeparam T - The type of the stream's value.
+ * @public
+ */
+export declare class FlowStreamAsync<T> extends FlowObservable<Promise<T>> {
+    /**
+     * Creates a new asynchronous FlowStream.
+     * @param updater - A function that receives a setter to update the stream's value.
+     * It should return a disposer function that will be called upon disposal.
+     * @remarks The updater function can invoke the setter asynchronously to update the stream.
+     * @public
+     */
+    constructor(updater: FlowStreamUpdater<T>);
+    /**
+     * Retrieves the current value of the stream as a Promise.
+     * @returns A Promise that resolves to the current value.
+     * @throws Error if the stream is disposed.
+     * @public
+     */
+    get(): Promise<T>;
+    /**
+     * Disposes the stream, releasing all resources.
+     * @remarks In addition to disposing the underlying observable, this method calls the disposer
+     * returned by the updater.
+     * @public
+     */
+    dispose(): void;
+    private _initialized;
+    private _awaitedValue?;
+    private _resolve;
+    private _disposer;
+    private _set;
+}
+//# sourceMappingURL=streamAsync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streamAsync.d.ts","sourceRoot":"","sources":["../../../src/advanced/streamAsync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9D;;;;;;OAMG;gBACS,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAWzC;;;;;OAKG;IACI,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;IAKxB;;;;;OAKG;IACa,OAAO,IAAI,IAAI;IAO/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAC,CAAI;IAE1B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,SAAS,CAAqB;IAEtC,OAAO,CAAC,IAAI;CAkBf"}

package/dist/types/basic/constant.d.ts

@@ -0,0 +1,32 @@
+import { FlowObservable } from './observable';
+/**
+ * Represents a reactive and immutable constant value computed lazily upon first access.
+ *
+ * @remarks This class extends FlowObservable and supports initializing the constant using either a direct value
+ * or a lazy initializer function. Once computed, the value is cached for all subsequent accesses.
+ *
+ * @typeparam T - The type of the constant value.
+ *
+ * @public
+ */
+export declare class FlowConstant<T> extends FlowObservable<T> {
+    /**
+     * Creates a new FlowConstant instance.
+     *
+     * @param value - Either a direct value of type T or a function returning a value of type T for lazy initialization.
+     * @public
+     */
+    constructor(value: T | (() => T));
+    /**
+     * Retrieves the constant value, computing it lazily if needed.
+     *
+     * Accessing this method will initialize the value if it has not been computed already.
+     * Throws an error if the instance has been disposed or if lazy initialization fails.
+     *
+     * @returns The cached constant value.
+     * @throws Error if the constant is disposed or cannot be initialized.
+     * @public
+     */
+    get(): T;
+}
+//# sourceMappingURL=constant.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../../src/basic/constant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;GASG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IAClD;;;;;OAKG;gBACS,KAAK,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAKhC;;;;;;;;;OASG;IACH,GAAG,IAAI,CAAC;CA6BX"}

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

@@ -0,0 +1,40 @@
+import { FlowGetter, FlowObservable } from './observable';
+import { FlowWatcher } from './signal';
+/**
+ * Represents a reactive derivation whose value is computed based on other reactive signals.
+ * @remarks
+ * It tracks dependencies automatically and recomputes its value when any dependency changes.
+ * Use FlowDerivation to create derived values in a reactive manner. It lazily initializes the computed value,
+ * ensuring that computations only occur when necessary.
+ * @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 two parameters:
+     * a getter and a watcher that respect dependency tracking.
+     * @public
+     */
+    constructor(compute: (get: FlowGetter, watch: FlowWatcher) => T);
+    /**
+     * Gets the current derived value.
+     * @returns The current computed value.
+     * @remarks
+     * This method lazily initializes and updates the derivation if it is marked as dirty. It throws an error
+     * if the derivation has been disposed.
+     * @public
+     */
+    get(): T;
+    private _initialized;
+    private _dirty;
+    private _trackedGet;
+    private _trackedWatch;
+    private _untrackedGet;
+    private _untrackedWatch;
+    private _trackedCompute;
+    private _untrackedCompute;
+    private _initEager;
+    private _initLazy;
+}
+//# sourceMappingURL=derivation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../../src/basic/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;;;;;;;;GAQG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACpD;;;;;OAKG;gBACS,OAAO,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,CAAC;IAK/D;;;;;;;OAOG;IACI,GAAG,IAAI,CAAC;IASf,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,WAAW,CAAyD;IAC5E,OAAO,CAAC,aAAa,CAAoD;IACzE,OAAO,CAAC,aAAa,CAAgD;IACrE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,iBAAiB,CAAW;IAEpC,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;CAyBpB"}

package/dist/types/basic/disposable.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents an object with a disposable lifecycle.
+ * @remarks
+ * Objects implementing this interface require explicit resource disposal.
+ * @public
+ */
+export interface FlowDisposable {
+    /**
+     * Disposes resources held by this object.
+     * @param options - Options to specify disposal behavior.
+     */
+    dispose(options?: {
+        self: boolean;
+    }): void;
+}
+/**
+ * Checks whether an object implements the FlowDisposable interface.
+ * @param obj - The object to test.
+ * @returns True if the object has a dispose method, otherwise false.
+ * @public
+ */
+export declare function isDisposable(obj: unknown): obj is FlowDisposable;
+//# sourceMappingURL=disposable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../../../src/basic/disposable.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC3B;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,cAAc,CAMhE"}

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

@@ -0,0 +1,56 @@
+import { FlowGetter } from './observable';
+import { FlowWatcher } from './signal';
+/**
+ * Represents a reactive effect that executes side-effect functions based
+ * on its tracked dependencies.
+ *
+ * @remarks
+ * The FlowEffect executes an apply function that performs side effects,
+ * running initially in a tracked mode to register dependencies and then in
+ * an untracked mode to re-execute the effect on updates.
+ *
+ * @public
+ */
+export declare class FlowEffect {
+    /**
+     * Creates a new FlowEffect.
+     *
+     * @param apply - A side-effect function that receives a getter and a watcher to
+     * access and register dependencies on reactive observables and signals.
+     *
+     * @remarks
+     * The provided function is executed immediately in a tracked mode to collect dependencies.
+     * On subsequent executions, it runs in an untracked mode.
+     *
+     * @public
+     */
+    constructor(apply: (get: FlowGetter, watch: FlowWatcher) => void);
+    /**
+     * Disposes the effect, unregistering all its tracked dependencies.
+     *
+     * @remarks
+     * Once disposed, the effect must no longer be used. Trying to dispose an effect
+     * that is already disposed will throw an error.
+     *
+     * @public
+     */
+    dispose(): void;
+    /**
+     * Indicates whether this effect has been disposed.
+     *
+     * @returns A boolean value that is true if the effect is disposed, false otherwise.
+     *
+     * @public
+     */
+    get disposed(): boolean;
+    private _disposed;
+    private _initialized;
+    private _dependencies;
+    private _trackedGet;
+    private _trackedWatch;
+    private _untrackedGet;
+    private _untrackedWatch;
+    private _trackedExec;
+    private _untrackedExec;
+}
+//# sourceMappingURL=effect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../../src/basic/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACnB;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI;IAOhE;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAQtB;;;;;;OAMG;IACH,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAID,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAyB;IAE9C,OAAO,CAAC,WAAW,CAAyD;IAC5E,OAAO,CAAC,aAAa,CAAoD;IACzE,OAAO,CAAC,aAAa,CAAgD;IACrE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,cAAc,CAAa;CAsBtC"}

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

@@ -0,0 +1,11 @@
+export { FlowSignal } from './signal';
+export { FlowState } from './state';
+export { FlowObservable } from './observable';
+export { FlowDerivation } from './derivation';
+export { FlowEffect } from './effect';
+export { FlowConstant } from './constant';
+export { isDisposable } from './disposable';
+export type { FlowGetter } from './observable';
+export type { FlowWatcher } from './signal';
+export type { FlowDisposable } from './disposable';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/basic/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/types/basic/observable.d.ts

@@ -0,0 +1,34 @@
+import { FlowSignal } from './signal';
+/**
+ * A function that retrieves the current value from a FlowObservable.
+ * @typeparam T - The type of the value held by the observable.
+ * @param observable - The FlowObservable instance to retrieve the value from.
+ * @returns The current value of the observable.
+ * @public
+ */
+export type FlowGetter = <T>(observable: FlowObservable<T>) => T;
+/**
+ * Represents a reactive observable that holds and tracks a value.
+ *
+ *
+ * @remarks Subclasses must implement the {@link FlowObservable.get} method to return the current value.
+ * @typeparam T - The type of the value held by the observable.
+ * @public
+ */
+export declare abstract class FlowObservable<T> extends FlowSignal {
+    /**
+     * Retrieves the current value stored in the observable.
+     * Subclasses must override this method to provide the current value.
+     * @returns The current value of type T.
+     * @public
+     */
+    abstract get(): T;
+    /**
+     * Subscribes a listener function to changes of the observable.
+     * The listener is executed immediately with the current value and on subsequent updates.
+     * @param listener - A callback function that receives the new value.
+     * @returns A disposer function to cancel the subscription.
+     */
+    subscribe(listener: (value: T) => void): () => void;
+}
+//# sourceMappingURL=observable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../../src/basic/observable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAEjE;;;;;;;GAOG;AACH,8BAAsB,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU;IACtD;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,IAAI,CAAC;IAWjB;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;CAMtD"}