@bodil/signal 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bodil/signal",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Preact Signals like signal implementation built on the TC39 Signals Proposal",
   "repository": {
     "type": "git",
@@ -10,7 +10,8 @@
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "exports": {
     ".": {

package/src/index.ts

@@ -0,0 +1,142 @@
+import { Signal } from "signal-polyfill";
+import { toDisposable, type Disposifiable } from "@bodil/disposable";
+import { Err, Ok, type Result, Async } from "@bodil/core";
+
+interface ReadableSignal<A> {
+    readonly value: A;
+    map<B>(fn: (value: A) => B): ComputedSignal<B>;
+    on(callback: (value: A) => void): Disposable;
+}
+
+export class StateSignal<A> extends Signal.State<A> implements ReadableSignal<A> {
+    get value(): A {
+        return this.get();
+    }
+
+    set value(value: A) {
+        this.set(value);
+    }
+
+    update(fn: (value: A) => A): void {
+        this.set(Signal.subtle.untrack(() => fn(this.get())));
+    }
+
+    readOnly(): ComputedSignal<A> {
+        return computed(() => this.get());
+    }
+
+    map<B>(fn: (value: A) => B): ComputedSignal<B> {
+        return computed(() => fn(this.get()));
+    }
+
+    on(callback: (value: A) => void): Disposable {
+        return subscribe(this, callback);
+    }
+}
+
+export class ComputedSignal<A> extends Signal.Computed<A> implements ReadableSignal<A> {
+    get value(): A {
+        return this.get();
+    }
+
+    map<B>(fn: (value: A) => B): ComputedSignal<B> {
+        return computed(() => fn(this.get()));
+    }
+
+    on(callback: (value: A) => void): Disposable {
+        return subscribe(this, callback);
+    }
+}
+
+type AnySignal<A> = StateSignal<A> | ComputedSignal<A>;
+
+export type { AnySignal as Signal };
+
+export const subtle = Signal.subtle;
+
+export function signal<A>(value: A, options?: Signal.Options<A>): StateSignal<A> {
+    return new StateSignal(value, options);
+}
+
+export function computed<A>(
+    fn: (this: ComputedSignal<A>) => A,
+    options?: Signal.Options<A>
+): ComputedSignal<A> {
+    return new ComputedSignal(fn, options);
+}
+
+let effectNeedsEnqueue = true;
+const effectWatcher = new Signal.subtle.Watcher(() => {
+    if (effectNeedsEnqueue) {
+        effectNeedsEnqueue = false;
+        queueMicrotask(effectProcess);
+    }
+});
+
+function effectProcess(): void {
+    effectNeedsEnqueue = true;
+    for (const sig of effectWatcher.getPending()) {
+        sig.get();
+    }
+    effectWatcher.watch();
+}
+
+export function effect(fn: () => Disposifiable | void): Disposable {
+    let cleanup: Disposable | undefined;
+    const computed = new ComputedSignal(() => {
+        if (cleanup !== undefined) {
+            cleanup[Symbol.dispose]();
+        }
+        const result = fn();
+        cleanup = result !== undefined ? toDisposable(result) : undefined;
+    });
+    effectWatcher.watch(computed);
+    computed.get();
+    return toDisposable(() => {
+        effectWatcher.unwatch(computed);
+        if (cleanup !== undefined) {
+            cleanup[Symbol.dispose]();
+        }
+    });
+}
+
+export function subscribe<A>(signal: ReadableSignal<A>, callback: (value: A) => void): Disposable {
+    return effect(() => callback(signal.value));
+}
+
+export function asyncComputed<A>(
+    fn: (abort: AbortSignal) => Promise<A>,
+    options?: Signal.Options<A>
+): Promise<ComputedSignal<A>> {
+    const result = Promise.withResolvers<ComputedSignal<A>>();
+    const stream = computed(() => Async.abortable(fn));
+    const sig: StateSignal<Result<A, Error>> = signal(Err(new Error()));
+    let job: Async.AbortableJob<A> | undefined = undefined;
+    let resolved = false;
+    const resolve = () => {
+        if (!resolved) {
+            resolved = true;
+            result.resolve(computed(() => sig.get().unwrapExact(), options));
+        }
+    };
+    effect(() => {
+        if (job !== undefined) {
+            job.abort();
+        }
+        job = stream.get();
+        job.result.then(
+            (next) => {
+                sig.set(Ok(next));
+                resolve();
+            },
+            (error) => {
+                if (job?.signal.aborted === true) {
+                    return;
+                }
+                sig.set(Err(error));
+                resolve();
+            }
+        );
+    });
+    return result.promise;
+}

package/src/signal.test.ts

@@ -0,0 +1,77 @@
+import { sleep } from "@bodil/core/async";
+import { expect, test } from "vitest";
+import { asyncComputed, effect, signal } from ".";
+
+test("Signal", async () => {
+    const sig = signal(0);
+    const result: Array<number> = [];
+    effect(() => void result.push(sig.value));
+    expect(result).toEqual([0]);
+    sig.value = 1;
+    sig.value = 2;
+    sig.value = 3;
+    expect(result).toEqual([0]);
+    const done = Promise.withResolvers<void>();
+    setTimeout(() => {
+        try {
+            expect(result).toEqual([0, 3]);
+            done.resolve();
+        } catch (e) {
+            done.reject(e as Error);
+        }
+    }, 1);
+    await done.promise;
+});
+
+test("signal equality", async () => {
+    const result: Array<number> = [];
+    const sig = signal(0);
+    effect(() => void result.push(sig.value));
+    expect(result).toEqual([0]);
+    sig.value = 1;
+    await sleep(1);
+    expect(result).toEqual([0, 1]);
+    sig.value = 1;
+    await sleep(1);
+    expect(result).toEqual([0, 1]);
+    sig.value = 2;
+    await sleep(1);
+    expect(result).toEqual([0, 1, 2]);
+    sig.value = 2;
+    await sleep(1);
+    expect(result).toEqual([0, 1, 2]);
+    sig.value = 3;
+    await sleep(1);
+    expect(result).toEqual([0, 1, 2, 3]);
+    sig.value = 3;
+    await sleep(1);
+    expect(result).toEqual([0, 1, 2, 3]);
+    sig.value = 2;
+    await sleep(1);
+    expect(result).toEqual([0, 1, 2, 3, 2]);
+});
+
+test("asyncComputed", async () => {
+    const s = signal(1);
+    const c = await asyncComputed(() => Promise.resolve(s.value + 1));
+    expect(c.value).toEqual(2);
+    try {
+        await asyncComputed(() => {
+            throw new Error("welp!");
+        });
+        throw new Error("computed error failed to throw");
+    } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toEqual("welp!");
+    }
+    s.value = 2;
+    expect(c.value).toEqual(2);
+    await sleep(1);
+    expect(c.value).toEqual(3);
+    s.value = 1;
+    s.value = 2;
+    s.value = 3;
+    expect(c.value).toEqual(3);
+    await sleep(1);
+    expect(c.value).toEqual(4);
+});