@ersbeth/picoflow 0.0.1 → 0.2.0

package/src/creators.ts

@@ -1,11 +1,19 @@
-import { FlowDerivation } from "./derivation";
-import { FlowEffect } from "./effect";
-import { FlowMap } from "./map";
-import type { FlowGetter } from "./observable";
-import { FlowResource } from "./resource";
-import { FlowSignal, type FlowWatcher } from "./signal";
-import { FlowState } from "./state";
-import { FlowStream } from "./stream";
+import {
+    FlowMap,
+    FlowResource,
+    FlowResourceAsync,
+    FlowStream,
+    FlowStreamAsync,
+} from "./advanced/";
+import { FlowArray } from "./advanced/array";
+import {
+    FlowConstant,
+    FlowDerivation,
+    FlowEffect,
+    FlowSignal,
+    FlowState,
+} from "./basic/";
+import type { FlowGetter, FlowWatcher } from "./basic/";
 
 /**
  * Creates a new reactive signal.
@@ -16,6 +24,16 @@ export function signal(): FlowSignal {
     return new FlowSignal();
 }
 
+/**
+ * Creates a new reactive constant.
+ * @param value - The value or a function that returns the value.
+ * @returns A new instance of {@link FlowConstant}.
+ * @public
+ */
+export function constant<T>(value: T | (() => T)): FlowConstant<T> {
+    return new FlowConstant<T>(value);
+}
+
 /**
  * Creates a new reactive state holding a value.
  * @typeparam T - The type of the state value.
@@ -23,7 +41,7 @@ export function signal(): FlowSignal {
  * @returns A new instance of {@link FlowState}.
  * @public
  */
-export function state<T>(value: T): FlowState<T> {
+export function state<T>(value: T | (() => T)): FlowState<T> {
     return new FlowState(value);
 }
 
@@ -31,12 +49,22 @@ export function state<T>(value: T): FlowState<T> {
  * Creates a new reactive resource that asynchronously fetches its value.
  * @typeparam T - The type of the resource value.
  * @param fn - An asynchronous function that fetches the resource value.
- * @param initial - The initial value of the resource.
  * @returns A new instance of {@link FlowResource}.
  * @public
  */
-export function resource<T>(fn: () => Promise<T>, initial: T): FlowResource<T> {
-    return new FlowResource(fn, initial);
+export function resource<T>(fn: () => Promise<T>): FlowResource<T> {
+    return new FlowResource(fn);
+}
+
+/**
+ * Creates a new reactive asynchronous resource that fetches its value.
+ * @typeparam T - The type of the resource value.
+ * @param fn - An asynchronous function that fetches the resource value.
+ * @returns A new instance of {@link FlowResourceAsync}.
+ * @public
+ */
+export function resourceAsync<T>(fn: () => Promise<T>): FlowResourceAsync<T> {
+    return new FlowResourceAsync(fn);
 }
 
 /**
@@ -44,15 +72,27 @@ export function resource<T>(fn: () => Promise<T>, initial: T): FlowResource<T> {
  * @typeparam T - The type of the stream value.
  * @param updater - A function that receives a setter to update the stream's value.
  * It should return a disposer function to clean up resources.
- * @param initial - The initial value of the stream.
  * @returns A new instance of {@link FlowStream}.
  * @public
  */
 export function stream<T>(
     updater: (set: (value: T) => void) => () => void,
-    initial: T,
 ): FlowStream<T> {
-    return new FlowStream(updater, initial);
+    return new FlowStream(updater);
+}
+
+/**
+ * Creates a new reactive asynchronous stream.
+ * @typeparam T - The type of the stream value.
+ * @param updater - A function that receives a setter to update the stream's value.
+ * It should return a disposer function to clean up resources.
+ * @returns A new instance of {@link FlowStreamAsync}.
+ * @public
+ */
+export function streamAsync<T>(
+    updater: (set: (value: T) => void) => () => void,
+): FlowStreamAsync<T> {
+    return new FlowStreamAsync(updater);
 }
 
 /**
@@ -99,3 +139,14 @@ export function map<K extends string | number | symbol, V>(
         new Map<K, V>(initial ? (Object.entries(initial) as [K, V][]) : []),
     );
 }
+
+/**
+ * Creates a new reactive array.
+ * @typeparam T - The type of the array elements.
+ * @param initial - An optional array of initial values.
+ * @returns A new instance of {@link FlowArray}.
+ * @public
+ */
+export function array<T>(initial?: T[]): FlowArray<T> {
+    return new FlowArray<T>(initial);
+}

package/src/index.ts

@@ -9,22 +9,37 @@
 export {
     signal,
     state,
+    constant,
     resource,
     stream,
     derivation,
     effect,
     map,
+    array,
+    streamAsync,
+    resourceAsync,
 } from "./creators";
-export type { FlowDerivation } from "./derivation";
-export type { FlowEffect } from "./effect";
-export type { FlowGetter, FlowObservable } from "./observable";
-export type { FlowResource } from "./resource";
-export type { FlowSignal, FlowWatcher } from "./signal";
-export type { FlowState } from "./state";
-export type { FlowMap } from "./map";
+export { isDisposable } from "./basic";
 export type {
+    FlowDerivation,
+    FlowEffect,
+    FlowGetter,
+    FlowObservable,
+    FlowSignal,
+    FlowWatcher,
+    FlowState,
+    FlowConstant,
+    FlowDisposable,
+} from "./basic/";
+export type {
+    FlowResource,
+    FlowMap,
+    FlowResourceAsync,
+    FlowStreamAsync,
     FlowStream,
-    FlowDisposer,
-    FlowSetter,
-    FlowUpdater,
-} from "./stream";
+    FlowStreamDisposer,
+    FlowStreamSetter,
+    FlowStreamUpdater,
+    FlowArray,
+    FlowArrayAction,
+} from "./advanced/";