@davidsouther/jiffies 2.2.4 → 2.3.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.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.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.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.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.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.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.js

@@ -1,21 +0,0 @@
-import { getLogger } from "../../log.js";
-import { getTotalCases } from "../describe.js";
-import { flattenResults } from "../execute.js";
-const logger = getLogger("Scope Test Runner");
-export function onConsole(results) {
-    const { executed, failed } = results;
-    logger.info("Executed test suite.", {
-        executed,
-        total: getTotalCases(),
-        failed,
-    });
-    const flat = flattenResults(results);
-    for (const { test } of flat) {
-        logger.debug(test);
-    }
-    for (const { test, stack } of flat) {
-        if (stack) {
-            logger.error(test, { stack });
-        }
-    }
-}

package/lib/esm/scope/display/dom.js

@@ -1,26 +0,0 @@
-import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js";
-import { DEFAULT_LOGGER, LEVEL } from "../../log.js";
-import { getTotalCases } from "../describe.js";
-import { flattenResults } from "../execute.js";
-export function displayStatistics(results, root = document.body) {
-    const { executed, failed } = results;
-    const logger = (() => {
-        try {
-            return makeHTMLLogger(`Executed ${executed} of ${getTotalCases()}; ${failed} failed.`);
-        }
-        catch (e) {
-            return DEFAULT_LOGGER;
-        }
-    })();
-    logger.level = LEVEL.DEBUG;
-    const flat = flattenResults(results);
-    for (const { test, stack } of flat) {
-        if (stack) {
-            logger.info(test);
-            logger.debug(`${stack}`);
-        }
-    }
-    if (isHTMLLogger(logger)) {
-        root.appendChild(logger.root);
-    }
-}

package/lib/esm/scope/display/junit.js

@@ -1,17 +0,0 @@
-import { xml } from "../../dom/xml.js";
-import { flattenResults } from "../execute.js";
-const cases = (results) => Object.entries(results).filter(([key]) => !["executed", "passed", "failed"].includes(key));
-export function asXML(results) {
-    return (`<?xml version="1.0" encoding="UTF-8" ?>` +
-        xml("testsuites", { tests: results.executed, failures: results.failed }, cases(results).map(([title, children]) => testsuite(title, children.executed, children.failed, flattenResults(children)))));
-}
-function testsuite(name, tests, failures, cases) {
-    const id = name.replace("s+", "_");
-    return xml("testsuite", { id, name, tests, failures }, cases.map(({ test, stack }) => testcase({ name: `${name} ${test}` }, stack ? [stack] : [])));
-}
-function testcase({ name, id = name.replace(/\s+/g, "_"), time = "0.00", }, failures) {
-    return xml("testcase", { id, name, time }, failures.map((stack) => failure({ text: stack })));
-}
-function failure({ text, message = text.split("\n")[0], }) {
-    return xml("failure", { message }, [`<![CDATA[${text}]]>`]);
-}