@davidsouther/jiffies 1.0.0 → 2.0.1

package/lib/cjs/observable/event.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collect = exports.marbles = exports.asEvents = exports.isEvent = exports.isFailed = exports.isCompleted = exports.isError = exports.isNext = exports.failed = exports.completed = exports.error = exports.next = void 0;
+const display_js_1 = require("../display.js");
+const next = (value) => ({
+    value,
+    completed: false,
+    failed: false,
+});
+exports.next = next;
+const error = (e) => ({
+    error: e,
+    completed: false,
+    failed: true,
+});
+exports.error = error;
+const completed = () => ({ completed: true, failed: false });
+exports.completed = completed;
+const failed = () => ({ completed: true, failed: true });
+exports.failed = failed;
+const isNext = (event) => !event.completed && !event.failed && event.value !== undefined;
+exports.isNext = isNext;
+const isError = (event) => event.failed && !event.completed;
+exports.isError = isError;
+const isCompleted = (event) => event.completed && !event.failed;
+exports.isCompleted = isCompleted;
+const isFailed = (event) => event.completed && event.failed;
+exports.isFailed = isFailed;
+const isEvent = (t) => {
+    const b = t;
+    return (0, exports.isNext)(b) || (0, exports.isError)(b) || (0, exports.isCompleted)(b);
+};
+exports.isEvent = isEvent;
+const asEvents = (a) => a.map((e) => ((0, exports.isEvent)(e) ? e : (0, exports.next)(e)));
+exports.asEvents = asEvents;
+const marble = (event) => (0, exports.isError)(event)
+    ? "X"
+    : (0, exports.isFailed)(event)
+        ? "!"
+        : (0, exports.isCompleted)(event)
+            ? "|"
+            : `(${(0, display_js_1.display)(event.value)})`;
+const marbles = (events) => `:${events.map(marble).join("-")}`;
+exports.marbles = marbles;
+const collect = (input$) => {
+    const collected = [];
+    const subscription = input$.subscribe({
+        next: (x) => {
+            collected.push((0, exports.next)(x));
+        },
+        error: (e) => {
+            collected.push((0, exports.error)(e));
+        },
+        complete: () => {
+            collected.push((0, exports.completed)());
+        },
+    });
+    subscription.unsubscribe();
+    return collected;
+};
+exports.collect = collect;

package/lib/cjs/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/cjs/observable/observable.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operator = exports.tap = exports.takeUntil = exports.reduce = exports.replay = exports.map = exports.last = exports.first = exports.distinct = exports.filter = exports.TapOperator = exports.TakeUntilOperator = exports.watch = exports.EventHandler = exports.eventListener = exports.ReplaySubject = exports.BehaviorSubject = exports.Subject = exports.SyncScheduler = exports.AsyncScheduler = exports.Observable = void 0;
+const log_js_1 = require("../log.js");
+exports.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;
+    },
+};
+exports.AsyncScheduler = {
+    execute(fn) {
+        return Promise.all(fn()).then(() => undefined);
+    },
+};
+exports.SyncScheduler = {
+    execute(fn) {
+        fn();
+    },
+};
+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 = exports.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(exports.operator.filter(fn));
+    }
+    distinct(fn = Object.is) {
+        return this.pipe(exports.operator.distinct(fn));
+    }
+    map(fn) {
+        return this.pipe(exports.operator.map(fn));
+    }
+    reduce(fn, init) {
+        return this.pipe(exports.operator.reduce(fn, init));
+    }
+    replay(n) {
+        return this.pipe(exports.operator.replay(n));
+    }
+    tap(s) {
+        return this.pipe(exports.operator.tap(s));
+    }
+}
+exports.Subject = Subject;
+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;
+    }
+}
+exports.BehaviorSubject = BehaviorSubject;
+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);
+    }
+}
+exports.ReplaySubject = ReplaySubject;
+function eventListener() {
+    const observable = new Subject();
+    function listener(e) {
+        e.preventDefault();
+        observable.next(e);
+    }
+    return [observable, listener];
+}
+exports.eventListener = eventListener;
+class EventHandler extends Subject {
+    eventFn;
+    constructor(eventFn) {
+        super();
+        this.eventFn = eventFn;
+    }
+    next(e) {
+        e.preventDefault();
+        super.next(e);
+    }
+}
+exports.EventHandler = EventHandler;
+const watch = (logger = log_js_1.DEFAULT_LOGGER) => (observable) => {
+    observable.tap({
+        next(t) {
+            logger.info(t);
+        },
+        complete() {
+            logger.info("Observable completed");
+        },
+        error(e) {
+            logger.warn(e);
+        },
+    });
+};
+exports.watch = watch;
+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));
+    }
+}
+class TakeUntilOperator extends Subject {
+    constructor(o) {
+        super();
+        o.subscribe(() => this.complete());
+    }
+}
+exports.TakeUntilOperator = TakeUntilOperator;
+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();
+    }
+}
+exports.TapOperator = TapOperator;
+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();
+    }
+}
+const filter = (fn) => new FilterOperator(fn);
+exports.filter = filter;
+const distinct = (fn) => new DistinctOperator(fn ?? Object.is);
+exports.distinct = distinct;
+const first = () => new FirstOperator();
+exports.first = first;
+const last = () => new LastOperator();
+exports.last = last;
+const map = (fn) => new MapOperator(fn);
+exports.map = map;
+const replay = (n) => new ReplaySubject(n);
+exports.replay = replay;
+const reduce = (fn, init) => new ReduceOperator(fn, init);
+exports.reduce = reduce;
+const takeUntil = (o) => new TakeUntilOperator(o);
+exports.takeUntil = takeUntil;
+const tap = (fn) => new TapOperator(fn);
+exports.tap = tap;
+exports.operator = {
+    filter: exports.filter,
+    distinct: exports.distinct,
+    first: exports.first,
+    last: exports.last,
+    map: exports.map,
+    replay: exports.replay,
+    reduce: exports.reduce,
+    takeUntil: exports.takeUntil,
+    tap: exports.tap,
+};

package/lib/cjs/observable/observable.test.js

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

package/lib/cjs/range.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.range = void 0;
+function range(start, end, stride = 1) {
+    const range = [];
+    for (let i = start; i < end; i += stride) {
+        range.push(i);
+    }
+    return range;
+}
+exports.range = range;