@ersbeth/picoflow 0.2.4 → 1.0.1

package/test/streamAsync.test.ts

@@ -2,193 +2,193 @@ 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");
-    });
+	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.pick();
+
+		counter.increment();
+		expect(await promise).toBe(1);
+		expect(await $stream.pick()).toBe(1);
+
+		counter.increment();
+		expect(await $stream.pick()).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.pick();
+
+		vi.advanceTimersToNextTimer();
+		expect(await promise).toBe(1);
+		expect(await $stream.pick()).toBe(1);
+
+		vi.advanceTimersToNextTimer();
+		expect(await $stream.pick()).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.pick()).toBe(1);
+
+		vi.advanceTimersToNextTimer();
+		expect(await $stream.pick()).toBe(2);
+
+		$stream.dispose();
+		vi.advanceTimersToNextTimer();
+		expect(() => $stream.pick()).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);
-    });
+	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((t) => effectFn($stream.get(t)));
+
+		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((t) => effectFn($stream.get(t)));
+
+		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((t) => effectFn($stream.get(t)));
+
+		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((t) => effectFn($stream.get(t)));
+
+		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

@@ -1,24 +1,25 @@
 {
-    "compilerOptions": {
-        "rootDir": ".",
-        "target": "ESNext",
+	"compilerOptions": {
+		"rootDir": ".",
+		"target": "ESNext",
 
-        "module": "ESNext",
-        "moduleResolution": "Bundler",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
 
-        "declaration": true,
-        "declarationMap": true,
-        "outDir": "dist/types",
+		"declaration": true,
+		"declarationMap": true,
+		"outDir": "dist/types",
+		"skipLibCheck": true,
 
-        "strict": true,
-        "verbatimModuleSyntax": true,
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "noFallthroughCasesInSwitch": true,
-        "noImplicitOverride": true,
-        "noImplicitReturns": true,
+		"strict": true,
+		"verbatimModuleSyntax": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noFallthroughCasesInSwitch": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
 
-        "stripInternal": true
-    },
-    "include": ["./src/**/*", "./test/**/*"]
+		"stripInternal": true
+	},
+	"include": ["./src/**/*", "./test/**/*"]
 }

package/typedoc.json

@@ -0,0 +1,37 @@
+{
+	"$schema": "https://typedoc.org/schema.json",
+	"entryPoints": ["src/index.ts"],
+	"entryPointStrategy": "resolve",
+	"out": "docs/api",
+	"docsRoot": "docs",
+	"plugin": ["typedoc-plugin-markdown", "typedoc-vitepress-theme"],
+	"readme": "none",
+	"hideGenerator": true,
+	"cleanOutputDir": true,
+	"excludePrivate": true,
+	"excludeProtected": true,
+	"excludeExternals": true,
+	"excludeInternal": true,
+	"entryFileName": "index.md",
+	"hidePageHeader": true,
+	"hideBreadcrumbs": false,
+	"useCodeBlocks": true,
+	"expandObjects": true,
+	"parametersFormat": "table",
+	"propertiesFormat": "table",
+	"enumMembersFormat": "table",
+	"typeDeclarationFormat": "table",
+	"indexFormat": "table",
+	"outputFileStrategy": "members",
+	"flattenOutputFiles": false,
+	"fileExtension": ".md",
+	"publicPath": "/api/",
+	"textContentMappings": {
+		"header.title": "API Reference"
+	},
+	"externalSymbolLinkMappings": {
+		"@ersbeth/picoflow": {
+			"FlowObservable._getRaw": "#"
+		}
+	}
+}

package/vite.config.ts

@@ -2,28 +2,28 @@ import { defineConfig } from "vite";
 import dts from "vite-plugin-dts";
 
 export default defineConfig({
-    root: "./src",
-    build: {
-        outDir: "../dist",
-        emptyOutDir: true,
-        lib: {
-            entry: "index.ts",
-            formats: ["es"],
-        },
-        target: "esnext",
-        minify: false,
-        rollupOptions: {
-            external: ["solid-js"],
-        },
-    },
+	root: "./src",
+	build: {
+		outDir: "../dist",
+		emptyOutDir: true,
+		lib: {
+			entry: "index.ts",
+			formats: ["es"],
+		},
+		target: "esnext",
+		minify: false,
+		rollupOptions: {
+			external: ["solid-js"],
+		},
+	},
 
-    plugins: [
-        dts({
-            include: "**/*",
-            outDir: "../dist/types",
-            compilerOptions: {
-                rootDir: "src",
-            },
-        }),
-    ],
+	plugins: [
+		dts({
+			include: "**/*",
+			outDir: "../dist/types",
+			compilerOptions: {
+				rootDir: "src",
+			},
+		}),
+	],
 });

package/vitest.config.ts

@@ -1,11 +1,11 @@
 import { defineConfig } from "vitest/config";
 
 export default defineConfig({
-    test: {
-        include: ["**/*.test.ts"],
-        coverage: {
-            reporter: ["text"],
-            include: ["src/**/*"],
-        },
-    },
+	test: {
+		include: ["**/*.test.ts"],
+		coverage: {
+			reporter: ["text"],
+			include: ["src/**/*"],
+		},
+	},
 });

package/api/doc/index.md

@@ -1,31 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md)
-
-## API Reference
-
-## Packages
-
-<table><thead><tr><th>
-
-Package
-
-
-</th><th>
-
-Description
-
-
-</th></tr></thead>
-<tbody><tr><td>
-
-[@ersbeth/picoflow](./picoflow.md)
-
-
-</td><td>
-
-PicoFlow is a lightweight reactive dataflow library that provides a set of reactive primitives such as signals, state, resources, streams, derivations, effects, and reactive maps.
-
-
-</td></tr>
-</tbody></table>

package/api/doc/picoflow.array.md

@@ -1,55 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@ersbeth/picoflow](./picoflow.md) &gt; [array](./picoflow.array.md)
-
-## array() function
-
-Creates a new reactive array.
-
-**Signature:**
-
-```typescript
-export declare function array<T>(initial?: T[]): FlowArray<T>;
-```
-
-## Parameters
-
-<table><thead><tr><th>
-
-Parameter
-
-
-</th><th>
-
-Type
-
-
-</th><th>
-
-Description
-
-
-</th></tr></thead>
-<tbody><tr><td>
-
-initial
-
-
-</td><td>
-
-T\[\]
-
-
-</td><td>
-
-_(Optional)_ An optional array of initial values.
-
-
-</td></tr>
-</tbody></table>
-**Returns:**
-
-[FlowArray](./picoflow.flowarray.md)<!-- -->&lt;T&gt;
-
-A new instance of [FlowArray](./picoflow.flowarray.md)<!-- -->.
-

package/api/doc/picoflow.constant.md

@@ -1,55 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@ersbeth/picoflow](./picoflow.md) &gt; [constant](./picoflow.constant.md)
-
-## constant() function
-
-Creates a new reactive constant.
-
-**Signature:**
-
-```typescript
-export declare function constant<T>(value: T | (() => T)): FlowConstant<T>;
-```
-
-## Parameters
-
-<table><thead><tr><th>
-
-Parameter
-
-
-</th><th>
-
-Type
-
-
-</th><th>
-
-Description
-
-
-</th></tr></thead>
-<tbody><tr><td>
-
-value
-
-
-</td><td>
-
-T \| (() =&gt; T)
-
-
-</td><td>
-
-The value or a function that returns the value.
-
-
-</td></tr>
-</tbody></table>
-**Returns:**
-
-[FlowConstant](./picoflow.flowconstant.md)<!-- -->&lt;T&gt;
-
-A new instance of [FlowConstant](./picoflow.flowconstant.md)<!-- -->.
-