@davidsouther/jiffies 1.1.0 → 2.0.0

package/lib/esm/observable/observable.d.ts

@@ -0,0 +1,132 @@
+import { Logger } from "../log.js";
+export interface FullSubscriber<T, E> {
+    next?: (t: T) => void | Promise<undefined>;
+    error?: (e: E) => void | Promise<undefined>;
+    complete?: () => void | Promise<undefined>;
+}
+export declare type Subscriber<T, E> = FullSubscriber<T, E> | ((t: T) => void | Promise<undefined>);
+export interface Subscription {
+    unsubscribe(): void;
+}
+export interface Observable<T, E = unknown> {
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+    pipe<T1>(o1: Subscriber<T, E> & Observable<T1, E>): Observable<T1, E>;
+    pipe<T1, T2>(o1: Subscriber<T, E> & Observable<T1, E>, o2: Subscriber<T1, E> & Observable<T2, E>): Observable<T2, E>;
+    filter(fn: (t: T) => boolean): Observable<T, E>;
+    distinct(fn?: (t1: T, t2: T) => boolean): Observable<T, E>;
+    map<U>(fn: (t: T) => U): Observable<U, E>;
+    reduce<A>(fn: (acc: A, t: T) => A, init: A): Observable<A, E>;
+    replay(n: number): Observable<T, E>;
+    tap(s: Subscriber<T, E>): Observable<T, E>;
+}
+export declare const Observable: {
+    of<T, E>(...ts: T[]): Observable<T, E>;
+    combineLatest<T1, T2, E_1>(o1: Observable<T1, E_1>, o2: Observable<T2, E_1>): Observable<[T1, T2], E_1>;
+};
+interface Scheduler {
+    execute(fn: () => (void | Promise<undefined>)[]): void | Promise<undefined>;
+}
+export declare const AsyncScheduler: Scheduler;
+export declare const SyncScheduler: Scheduler;
+export declare class Subject<T, E = unknown, T2 = T> implements FullSubscriber<T, E>, Observable<T, E> {
+    #private;
+    private readonly scheduler;
+    get $(): Observable<T, E>;
+    get hot(): boolean;
+    get cold(): boolean;
+    constructor(scheduler?: Scheduler);
+    onWarm(fn: Function): void;
+    next(t: T | T2): void | Promise<undefined>;
+    error(e: E): void | Promise<undefined>;
+    complete(): void | Promise<undefined>;
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+    pipe<T1>(o1: Subscriber<T, E> & Observable<T1, E>): Observable<T1, E>;
+    pipe<T1, T2>(o1: Subscriber<T, E> & Observable<T1, E>, o2: Subscriber<T1, E> & Observable<T2, E>): Observable<T2, E>;
+    filter(fn: (t: T) => boolean): Observable<T, E>;
+    distinct(fn?: (t1: T, t2: T) => boolean): Observable<T, E>;
+    map<U>(fn: (t: T) => U): Observable<U, E>;
+    reduce<A>(fn: (acc: A, t: T) => A, init: A): Observable<A, E>;
+    replay(n: number): Observable<T, E>;
+    tap(s: Subscriber<T, E>): Observable<T, E>;
+}
+export declare class BehaviorSubject<T, E = unknown, T2 = T> extends Subject<T, E, T2> {
+    #private;
+    constructor(t: T, scheduler?: Scheduler);
+    next(t: T | T2): void | Promise<undefined>;
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+    get current(): T;
+}
+export declare class ReplaySubject<T, E = unknown> extends Subject<T, E> {
+    #private;
+    private readonly n;
+    constructor(n: number, scheduler?: Scheduler);
+    next(t: T): void | Promise<undefined>;
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+}
+export declare function eventListener<E extends Event>(): (Subject<E, unknown, E> | ((e: E) => void))[];
+export declare class EventHandler<E extends Event> extends Subject<E> {
+    private readonly eventFn;
+    constructor(eventFn: (e: E) => void | Promise<undefined>);
+    next(e: E): void;
+}
+export declare const watch: <T, E>(logger?: Logger) => (observable: Observable<T, E>) => void;
+declare class MapOperator<T, U, E> extends Subject<U, E, T> implements FullSubscriber<T, E>, Observable<U, E> {
+    private readonly mapFn;
+    constructor(mapFn: (t: T) => U);
+    next(t: T): void | Promise<undefined>;
+}
+declare class FilterOperator<T, E> extends Subject<T, E> implements FullSubscriber<T, E>, Observable<T, E> {
+    private readonly filterFn;
+    constructor(filterFn: (t: T) => boolean);
+    next(t: T): void | Promise<undefined>;
+}
+declare class DistinctOperator<T, E> extends Subject<T, E> implements FullSubscriber<T, E>, Observable<T, E> {
+    #private;
+    private readonly distinctFn;
+    constructor(distinctFn?: (t1: T, t2: T) => boolean);
+    next(t: T): void | Promise<undefined>;
+}
+declare class ReduceOperator<A, T, E> extends BehaviorSubject<A, E, T> {
+    private readonly fn;
+    constructor(fn: (acc: A, t: T) => A, init: A);
+    next(t: T): void | Promise<undefined>;
+}
+export declare class TakeUntilOperator<T, E> extends Subject<T, E> {
+    constructor(o: Observable<unknown, unknown>);
+}
+export declare class TapOperator<T, E> extends Subject<T, E> {
+    private readonly subscriber;
+    constructor(fn: Subscriber<T, E>);
+    next(t: T): void | Promise<undefined>;
+    error(e: E): void | Promise<undefined>;
+    complete(): void | Promise<undefined>;
+}
+declare class FirstOperator<T, E> extends Subject<T, E> {
+    next(t: T): void | Promise<undefined>;
+}
+declare class LastOperator<T, E = Error> extends Subject<T, E> {
+    #private;
+    next(t: T): void;
+    complete(): void | Promise<undefined>;
+}
+export declare const filter: <T, E>(fn: (t: T) => boolean) => FilterOperator<T, E>;
+export declare const distinct: <T, E>(fn?: ((t1: T, t2: T) => boolean) | undefined) => DistinctOperator<T, E>;
+export declare const first: <T, E>() => FirstOperator<T, E>;
+export declare const last: <T, E>() => LastOperator<T, E>;
+export declare const map: <T1, T2, E>(fn: (t: T1) => T2) => MapOperator<T1, T2, E>;
+export declare const replay: <T, E>(n: number) => ReplaySubject<T, E>;
+export declare const reduce: <A, T, E>(fn: (acc: A, t: T) => A, init: A) => ReduceOperator<A, T, E>;
+export declare const takeUntil: <T, E>(o: Observable<unknown, unknown>) => TakeUntilOperator<T, E>;
+export declare const tap: <T, E>(fn: Subscriber<T, E>) => TapOperator<T, E>;
+export declare const operator: {
+    filter: <T, E>(fn: (t: T) => boolean) => FilterOperator<T, E>;
+    distinct: <T_1, E_1>(fn?: ((t1: T_1, t2: T_1) => boolean) | undefined) => DistinctOperator<T_1, E_1>;
+    first: <T_2, E_2>() => FirstOperator<T_2, E_2>;
+    last: <T_3, E_3>() => LastOperator<T_3, E_3>;
+    map: <T1, T2, E_4>(fn: (t: T1) => T2) => MapOperator<T1, T2, E_4>;
+    replay: <T_4, E_5>(n: number) => ReplaySubject<T_4, E_5>;
+    reduce: <A, T_5, E_6>(fn: (acc: A, t: T_5) => A, init: A) => ReduceOperator<A, T_5, E_6>;
+    takeUntil: <T_6, E_7>(o: Observable<unknown, unknown>) => TakeUntilOperator<T_6, E_7>;
+    tap: <T_7, E_8>(fn: Subscriber<T_7, E_8>) => TapOperator<T_7, E_8>;
+};
+export {};

package/lib/esm/observable/observable.js

@@ -0,0 +1,343 @@
+import { DEFAULT_LOGGER } from "../log.js";
+export const Observable = {
+    of(...ts) {
+        const subject = new Subject();
+        (async function next() {
+            if (subject.cold) {
+                subject.onWarm(next);
+                return;
+            }
+            if (ts.length === 0) {
+                subject.complete();
+                return;
+            }
+            const t = ts.shift();
+            await subject.next(t);
+            next();
+        })();
+        return subject;
+    },
+    combineLatest(o1, o2) {
+        let latestSubject = new Subject();
+        let o1LatestSet = false;
+        let o1Latest;
+        let o2LatestSet = false;
+        let o2Latest;
+        function next() {
+            if (o1LatestSet && o2LatestSet) {
+                latestSubject.next([o1Latest, o2Latest]);
+            }
+        }
+        function error(e) {
+            latestSubject.error(e);
+        }
+        function complete() {
+            latestSubject.complete();
+            o1sub.unsubscribe();
+            o2sub.unsubscribe();
+        }
+        let o1sub = o1.subscribe({
+            next(t) {
+                o1Latest = t;
+                o1LatestSet = true;
+                next();
+            },
+            error,
+            complete,
+        });
+        let o2sub = o2.subscribe({
+            next(t) {
+                o2Latest = t;
+                o2LatestSet = true;
+                next();
+            },
+            error,
+            complete,
+        });
+        return latestSubject;
+    },
+};
+export const AsyncScheduler = {
+    execute(fn) {
+        return Promise.all(fn()).then(() => undefined);
+    },
+};
+export const SyncScheduler = {
+    execute(fn) {
+        fn();
+    },
+};
+export class Subject {
+    scheduler;
+    #coldWaiters = new Set();
+    #subscribers = new Set();
+    #complete = false;
+    get $() {
+        return this;
+    }
+    get hot() {
+        return this.#subscribers.size > 0;
+    }
+    get cold() {
+        return !this.hot;
+    }
+    constructor(scheduler = AsyncScheduler) {
+        this.scheduler = scheduler;
+    }
+    onWarm(fn) {
+        if (this.cold)
+            this.#coldWaiters.add(fn);
+    }
+    next(t) {
+        if (this.#complete)
+            throw new Error("Cannot call next on a completed subject");
+        return this.scheduler.execute(() => [...this.#subscribers].map((s) => s.next?.(t)));
+    }
+    error(e) {
+        if (this.#complete)
+            throw new Error("Cannot call error on a completed subject");
+        return this.scheduler.execute(() => [...this.#subscribers].map((s) => s.error?.(e)));
+    }
+    complete() {
+        if (this.#complete)
+            throw new Error("Cannot call complete on a completed subject");
+        this.#complete = true;
+        const finished = this.scheduler.execute(() => [...this.#subscribers].map((s) => s.complete?.()));
+        this.#subscribers.clear(); // Free subscribers for garbage collection
+        return finished;
+    }
+    subscribe(subscriber) {
+        if (this.#complete)
+            throw new Error("Cannot call subscribe on a completed subject");
+        if (subscriber instanceof Function) {
+            subscriber = { next: subscriber };
+        }
+        this.#subscribers.add(subscriber);
+        [...this.#coldWaiters].forEach((w) => w());
+        this.#coldWaiters.clear();
+        return {
+            unsubscribe: () => this.#subscribers.delete(subscriber),
+        };
+    }
+    pipe(...os) {
+        this.subscribe(os[0]);
+        for (let i = 1; i < os.length; i++) {
+            os[i - 1].subscribe(os[i]);
+        }
+        return os[os.length - 1];
+    }
+    filter(fn) {
+        return this.pipe(operator.filter(fn));
+    }
+    distinct(fn = Object.is) {
+        return this.pipe(operator.distinct(fn));
+    }
+    map(fn) {
+        return this.pipe(operator.map(fn));
+    }
+    reduce(fn, init) {
+        return this.pipe(operator.reduce(fn, init));
+    }
+    replay(n) {
+        return this.pipe(operator.replay(n));
+    }
+    tap(s) {
+        return this.pipe(operator.tap(s));
+    }
+}
+export class BehaviorSubject extends Subject {
+    #current;
+    constructor(t, scheduler) {
+        super(scheduler);
+        this.#current = t;
+    }
+    next(t) {
+        this.#current = t;
+        return super.next(t);
+    }
+    subscribe(subscriber) {
+        if (subscriber instanceof Function) {
+            subscriber = { next: subscriber };
+        }
+        subscriber.next?.(this.#current);
+        return super.subscribe(subscriber);
+    }
+    get current() {
+        return this.#current;
+    }
+}
+export class ReplaySubject extends Subject {
+    n;
+    #history = [];
+    constructor(n, scheduler) {
+        super(scheduler);
+        this.n = n;
+    }
+    next(t) {
+        this.#history.push(t);
+        if (this.#history.length > this.n) {
+            this.#history.shift();
+        }
+        return super.next(t);
+    }
+    subscribe(subscriber) {
+        if (subscriber instanceof Function) {
+            subscriber = { next: subscriber };
+        }
+        const history = [...this.#history];
+        (function send() {
+            if (history.length == 0)
+                return;
+            const t = history.shift();
+            subscriber.next?.(t);
+            new Promise(send);
+        })();
+        return super.subscribe(subscriber);
+    }
+}
+export function eventListener() {
+    const observable = new Subject();
+    function listener(e) {
+        e.preventDefault();
+        observable.next(e);
+    }
+    return [observable, listener];
+}
+export class EventHandler extends Subject {
+    eventFn;
+    constructor(eventFn) {
+        super();
+        this.eventFn = eventFn;
+    }
+    next(e) {
+        e.preventDefault();
+        super.next(e);
+    }
+}
+export const watch = (logger = DEFAULT_LOGGER) => (observable) => {
+    observable.tap({
+        next(t) {
+            logger.info(t);
+        },
+        complete() {
+            logger.info("Observable completed");
+        },
+        error(e) {
+            logger.warn(e);
+        },
+    });
+};
+class MapOperator extends Subject {
+    mapFn;
+    constructor(mapFn) {
+        super();
+        this.mapFn = mapFn;
+    }
+    next(t) {
+        return super.next(this.mapFn(t));
+    }
+}
+class FilterOperator extends Subject {
+    filterFn;
+    constructor(filterFn) {
+        super();
+        this.filterFn = filterFn;
+    }
+    next(t) {
+        return this.filterFn(t) ? super.next(t) : undefined;
+    }
+}
+class DistinctOperator extends Subject {
+    distinctFn;
+    #prior = undefined;
+    constructor(distinctFn = Object.is) {
+        super();
+        this.distinctFn = distinctFn;
+    }
+    next(t) {
+        if (this.#prior === undefined) {
+            this.#prior = t;
+            return super.next(t);
+        }
+        const same = this.distinctFn(this.#prior, t);
+        if (!same) {
+            this.#prior = t;
+            return super.next(t);
+        }
+        return undefined;
+    }
+}
+class ReduceOperator extends BehaviorSubject {
+    fn;
+    constructor(fn, init) {
+        super(init);
+        this.fn = fn;
+    }
+    next(t) {
+        return super.next(this.fn(this.current, t));
+    }
+}
+export class TakeUntilOperator extends Subject {
+    constructor(o) {
+        super();
+        o.subscribe(() => this.complete());
+    }
+}
+export class TapOperator extends Subject {
+    subscriber;
+    constructor(fn) {
+        super();
+        this.subscriber = fn instanceof Function ? { next: fn } : fn;
+    }
+    next(t) {
+        this.subscriber.next?.(t);
+        return super.next(t);
+    }
+    error(e) {
+        this.subscriber.error?.(e);
+        return super.error(e);
+    }
+    complete() {
+        this.subscriber.complete?.();
+        return super.complete();
+    }
+}
+class FirstOperator extends Subject {
+    next(t) {
+        const next = super.next(t);
+        this.complete();
+        return next;
+    }
+}
+class LastOperator extends Subject {
+    #latest;
+    next(t) {
+        this.#latest = t;
+    }
+    complete() {
+        if (this.#latest !== undefined) {
+            super.next(this.#latest);
+        }
+        return super.complete();
+    }
+}
+export const filter = (fn) => new FilterOperator(fn);
+export const distinct = (fn) => new DistinctOperator(fn ?? Object.is);
+export const first = () => new FirstOperator();
+export const last = () => new LastOperator();
+export const map = (fn) => new MapOperator(fn);
+export const replay = (n) => new ReplaySubject(n);
+export const reduce = (fn, init) => new ReduceOperator(fn, init);
+export const takeUntil = (o) => new TakeUntilOperator(o);
+export const tap = (fn) => new TapOperator(fn);
+export const operator = {
+    filter,
+    distinct,
+    first,
+    last,
+    map,
+    replay,
+    reduce,
+    takeUntil,
+    tap,
+};

package/lib/esm/observable/observable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/observable/observable.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "../scope/index.js";
+import { Observable, Subject, filter, map } from "./observable.js";
+describe("Observables", () => {
+    describe("basics", () => {
+        it("can create and observe a scalar subject", async () => {
+            const subject = new Subject();
+            let resolved = 42;
+            subject.subscribe({
+                next: (n) => {
+                    resolved = n;
+                },
+            });
+            expect(resolved).toBe(42);
+            await subject.next(64);
+            expect(resolved).toBe(64);
+        });
+    });
+    describe("creation", () => {
+        it("builds an observable of items", async () => {
+            const stream = Observable.of(2, 4, 8, 16);
+            let values = [];
+            await new Promise((resolve) => {
+                stream.subscribe({
+                    next: (n) => {
+                        values.unshift(n);
+                    },
+                    complete: () => {
+                        resolve();
+                    },
+                });
+            });
+            expect(values).toEqual([16, 8, 4, 2]);
+        });
+    });
+    describe("pipes", () => {
+        it("runs a pipe", async () => {
+            const subject = new Subject();
+            let resolved = 0;
+            const inflate = (i) => (n) => n + i;
+            const biggerThan = (i) => (n) => n > i;
+            const assign = (n) => {
+                resolved = n;
+            };
+            subject.pipe(map(inflate(22)), filter(biggerThan(70))).subscribe(assign);
+            expect(resolved).toBe(0);
+            await subject.next(42);
+            expect(resolved).toBe(0);
+            await subject.next(50);
+            expect(resolved).toBe(72);
+        });
+    });
+    describe("Subject", () => {
+        it("is callable", async () => {
+            const subject = new Subject();
+            let resolved = 0;
+            subject.subscribe((n) => {
+                resolved = n;
+            });
+            await subject.next(42);
+            expect(resolved).toBe(42);
+        });
+    });
+});

package/lib/esm/range.d.ts

@@ -0,0 +1 @@
+export declare function range(start: number, end: number, stride?: number): number[];

package/{build → lib/esm}/range.js

@@ -1,7 +1,7 @@
-export function range(start, end, stride = 1) {
-    const range = [];
-    for (let i = start; i < end; i += stride) {
-        range.push(i);
-    }
-    return range;
-}
+export function range(start, end, stride = 1) {
+    const range = [];
+    for (let i = start; i < end; i += stride) {
+        range.push(i);
+    }
+    return range;
+}

package/lib/esm/result.d.ts

@@ -0,0 +1,31 @@
+export declare type None = null;
+export declare type Some<T> = T;
+export declare type Option<T> = Some<T> | None;
+export declare type Err<E = Error> = {
+    err: E;
+    map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
+};
+export declare type Ok<T> = {
+    ok: T;
+    map: <U>(fn: (t: T) => Result<U>) => Result<U>;
+};
+export declare type Result<T, E = Error> = Ok<T> | Err<E>;
+export declare const isNone: <T>(s: Option<T>) => s is null;
+export declare const isSome: <T>(s: Option<T>) => s is T;
+export declare function None<T = unknown>(_?: T): Option<T>;
+export declare function Some<T>(t: Option<T>): Option<T>;
+export declare function Some<T>(t: T): Option<T>;
+export declare const isOk: <T, E>(t: Result<T, E>) => t is Ok<T>;
+export declare const isErr: <T, E>(e: Result<T, E>) => e is Err<E>;
+export declare const isResult: <T, E>(t: Result<T, E>) => t is Result<T, E>;
+export declare function Ok<T>(ok: Ok<T>): T;
+export declare function Ok<T>(t: T): Ok<T>;
+export declare function Err<E>(e: Err<E>): E;
+export declare function Err<E>(e: E): Err<E>;
+export declare function Err<E>(e: string): Err<E>;
+export declare function unwrap<T, E>(result: Result<T, E>): T | never;
+export declare function unwrap<O>(some: Option<O>): O | never;
+export declare function unwrapOr<T, E>(result: Result<T, E>, def: T): T;
+export declare function unwrapOr<T>(some: Some<T>, def: T): T;
+export declare function unwrapOrElse<T, E>(result: Result<T, Error>, def: () => T): T;
+export declare function unwrapOrElse<T>(some: Some<T>, def: () => T): T;