@davidsouther/jiffies 2.2.5 → 2026.4.0

package/lib/esm/observable/observable.js

@@ -1,343 +0,0 @@
-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

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

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

@@ -1,63 +0,0 @@
-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

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

package/lib/esm/range.js

@@ -1,7 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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;

package/lib/esm/result.js

@@ -1,65 +0,0 @@
-export const isNone = (s) => s === null;
-export const isSome = (s) => s != null;
-export function None(_) {
-    return null;
-}
-export function Some(t) {
-    return t;
-}
-export const isOk = (t) => Object.prototype.hasOwnProperty.call(t ?? {}, "ok");
-export const isErr = (e) => Object.prototype.hasOwnProperty.call(e, "err");
-export const isResult = (t) => isOk(t) || isErr(t);
-export function Ok(t) {
-    return isOk(t)
-        ? t.ok
-        : {
-            ok: t,
-            map(fn) {
-                return fn(Ok(this));
-            },
-        };
-}
-export function Err(e) {
-    return (e.err ?? {
-        err: e,
-        map(_fn) {
-            return this;
-        },
-    });
-}
-export function unwrap(t) {
-    if (isNone(t)) {
-        throw new Error(`Attempted to unwrap None`);
-    }
-    if (isErr(t)) {
-        throw Err(t);
-    }
-    if (isOk(t)) {
-        return Ok(t);
-    }
-    return t;
-}
-export function unwrapOr(t, def) {
-    if (isNone(t)) {
-        return def;
-    }
-    if (isErr(t)) {
-        return def;
-    }
-    if (isOk(t)) {
-        return Ok(t);
-    }
-    return t;
-}
-export function unwrapOrElse(t, def) {
-    if (isNone(t)) {
-        return def();
-    }
-    if (isErr(t)) {
-        return def();
-    }
-    if (isOk(t)) {
-        return Ok(t);
-    }
-    return t;
-}

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

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

package/lib/esm/result.test.js

@@ -1,76 +0,0 @@
-import { Err, None, Ok, Some, unwrap, unwrapOr, unwrapOrElse, } from "./result.js";
-import { describe, it } from "./scope/describe.js";
-import { expect } from "./scope/expect.js";
-describe("Result", () => {
-    it("converts Nones", () => {
-        const a = None();
-        expect(a).toBeNull();
-        const b = None();
-        expect(b).toBeNull();
-        const c = Some(a);
-        expect(c).toBeNull();
-        const d = Some(b);
-        expect(d).toBeNull();
-    });
-    it("converts Somes", () => {
-        const a = Some("a");
-        expect(a).toBe("a");
-        const b = Some(a);
-        expect(b).toBe("a");
-    });
-    it("converts Errs", () => {
-        const a = Err(new Error("a error"));
-        const b = Err(a);
-        expect(b).toMatchObject({ message: "a error" });
-        // Assign Err to Result
-        const c = a;
-    });
-    it("converts Oks", () => {
-        const a = Ok("a ok");
-        const b = Ok(a);
-        expect(b).toBe("a ok");
-        // Assign ok to Result
-        const c = a;
-    });
-    it("unwraps", () => {
-        const a = Some("some");
-        const b = None();
-        const c = Ok("ok");
-        const d = Err(new Error("err"));
-        const e = "else";
-        expect(unwrap(a)).toBe("some");
-        expect(unwrap(c)).toBe("ok");
-        expect(() => unwrap(b)).toThrow("Attempted to unwrap None");
-        expect(() => unwrap(d)).toThrow("err");
-        expect(unwrap(e)).toBe("else");
-    });
-    it("unwrapsOrs", () => {
-        const a = Some("some");
-        const b = None();
-        const c = Ok("ok");
-        const d = Err(new Error("err"));
-        const e = "else";
-        expect(unwrapOr(a, "z")).toBe("some");
-        expect(unwrapOr(c, "z")).toBe("ok");
-        expect(unwrapOr(b, "z")).toBe("z");
-        expect(unwrapOr(d, "z")).toBe("z");
-        expect(unwrapOr(e, "z")).toBe("else");
-    });
-    it("unwrapsOrElse", () => {
-        const a = Some("some");
-        const b = None();
-        const c = Ok("ok");
-        const d = Err(new Error("err"));
-        const e = "else";
-        expect(unwrapOrElse(a, () => "z")).toBe("some");
-        expect(unwrapOrElse(c, () => "z")).toBe("ok");
-        expect(unwrapOrElse(b, () => "z")).toBe("z");
-        expect(unwrapOrElse(d, () => "z")).toBe("z");
-        expect(unwrapOrElse(e, () => "z")).toBe("else");
-    });
-    it("allows Result<void> with Ok()", () => {
-        let a;
-        a = Ok();
-        expect(unwrap(a)).toBe(undefined);
-    });
-});

package/lib/esm/safe.d.ts

@@ -1 +0,0 @@
-export declare const safe: <A extends unknown[], R>(fn: (...args: A) => R, r: R) => (...args: A) => R;

package/lib/esm/safe.js

@@ -1,10 +0,0 @@
-import { error } from "./log.js";
-export const safe = (fn, r) => (...args) => {
-    try {
-        return fn(...args);
-    }
-    catch (e) {
-        error(`${e}`);
-        return r;
-    }
-};

package/lib/esm/scope/describe.d.ts

@@ -1,18 +0,0 @@
-import { TestCase } from "./scope.js";
-export declare const beforeall: unique symbol;
-export declare const beforeeach: unique symbol;
-export declare const afterall: unique symbol;
-export declare const aftereach: unique symbol;
-export declare function rootCases(): TestCase;
-export declare function getTotalCases(): number;
-export declare function getSkippedCases(): number;
-export declare function describe(title: string, block: Function): void;
-export declare function it(title: string, block: Function): void;
-export declare namespace it {
-    var skip: (title: string, _block: Function) => void;
-}
-export declare function beforeEach(fn: () => void): void;
-export declare function beforeAll(fn: () => void): void;
-export declare function afterEach(fn: () => void): void;
-export declare function afterAll(fn: () => void): void;
-export declare function cleanState<State extends {}>(init: () => State, runner?: (action: () => void) => void): State;

package/lib/esm/scope/describe.js

@@ -1,60 +0,0 @@
-import { assert } from "../assert.js";
-import { getLogger } from "../log.js";
-import * as state from "./state.js";
-export const beforeall = Symbol("beforeAll");
-export const beforeeach = Symbol("beforeEach");
-export const afterall = Symbol("afterAll");
-export const aftereach = Symbol("afterEach");
-const logger = getLogger("scope");
-const CASES = {};
-let cases = [CASES];
-let totalCases = 0;
-let skippedCases = 0;
-function push(title) {
-    const next = (cases[0][title] = cases[0][title] ?? {});
-    cases.unshift(next);
-}
-function pop() {
-    cases.shift();
-}
-export function rootCases() {
-    return CASES;
-}
-export function getTotalCases() {
-    return totalCases;
-}
-export function getSkippedCases() {
-    return skippedCases;
-}
-export function describe(title, block) {
-    logger.debug(`describe(${title})`);
-    push(title);
-    block();
-    pop();
-}
-export function it(title, block) {
-    logger.debug(`it(${title})`);
-    assert(cases[0][title] == undefined, `Block already has test ${title}`);
-    totalCases += 1;
-    cases[0][title] = block;
-}
-it.skip = (title, _block) => {
-    logger.debug(`it.skip(${title})`);
-    totalCases += 1;
-    skippedCases += 1;
-};
-export function beforeEach(fn) {
-    cases[0][beforeeach] = fn;
-}
-export function beforeAll(fn) {
-    cases[0][beforeall] = fn;
-}
-export function afterEach(fn) {
-    cases[0][aftereach] = fn;
-}
-export function afterAll(fn) {
-    cases[0][afterall] = fn;
-}
-export function cleanState(init, runner = beforeEach) {
-    return state.cleanState(init, runner);
-}

package/lib/esm/scope/display/console.d.ts

@@ -1,2 +0,0 @@
-import { TestResult } from "../scope.js";
-export declare function onConsole(results: TestResult): void;