@davidsouther/jiffies 1.0.0 → 2.0.1

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/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;

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

@@ -1,4 +1,4 @@
-export const isNone = (s) => s == null;
+export const isNone = (s) => s === null;
 export const isSome = (s) => s != null;
 export function None(_) {
     return null;

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

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

package/lib/esm/safe.d.ts

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

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

@@ -0,0 +1,18 @@
+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/{build → lib/esm}/scope/describe.js

@@ -1,4 +1,6 @@
+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");
@@ -7,8 +9,9 @@ const logger = getLogger("scope");
 const CASES = {};
 let cases = [CASES];
 let totalCases = 0;
+let skippedCases = 0;
 function push(title) {
-    const next = (cases[0][title] = {});
+    const next = (cases[0][title] = cases[0][title] ?? {});
     cases.unshift(next);
 }
 function pop() {
@@ -20,6 +23,9 @@ export function rootCases() {
 export function getTotalCases() {
     return totalCases;
 }
+export function getSkippedCases() {
+    return skippedCases;
+}
 export function describe(title, block) {
     logger.debug(`describe(${title})`);
     push(title);
@@ -28,9 +34,15 @@ export function describe(title, block) {
 }
 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;
 }
@@ -44,9 +56,5 @@ export function afterAll(fn) {
     cases[0][afterall] = fn;
 }
 export function cleanState(init, runner = beforeEach) {
-    const state = {};
-    runner(() => {
-        Object.assign(state, init());
-    });
-    return state;
+    return state.cleanState(init, runner);
 }

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

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

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

@@ -0,0 +1,3 @@
+import { DOMElement } from "../../dom/dom.js";
+import { TestResult } from "../scope.js";
+export declare function displayStatistics(results: TestResult, root?: DOMElement): void;

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

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

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

@@ -0,0 +1,12 @@
+import { TestResult, TestSummary } from "./scope.js";
+export declare function execute(cases?: import("./scope.js").TestCase): Promise<TestResult>;
+export declare function getError({ error }: TestResult): number | TestResult | TestSummary | "unknown error";
+export interface FlatResult {
+    test: string;
+    stack?: string | number | TestResult | TestSummary;
+    stats: {
+        executed: number;
+        failed: number;
+    };
+}
+export declare function flattenResults(results: TestResult, prefix?: string): FlatResult[];

package/{build → lib/esm}/scope/execute.js

@@ -1,5 +1,5 @@
 import { afterall, aftereach, beforeall, beforeeach, rootCases, } from "./describe.js";
-export async function execute(prefix = "", cases = rootCases()) {
+export async function execute(cases = rootCases()) {
     const beforeallfn = cases[beforeall] ?? (() => { });
     const beforeeachfn = cases[beforeeach] ?? (() => { });
     const afterallfn = cases[afterall] ?? (() => { });
@@ -31,7 +31,7 @@ export async function execute(prefix = "", cases = rootCases()) {
             }
         }
         else if (block) {
-            const run = await execute(title, block);
+            const run = await execute(block);
             result.executed += run.executed;
             result.passed += run.passed;
             result.failed += run.failed;

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

@@ -0,0 +1,23 @@
+export declare class Matcher<T> {
+    actual: T;
+    constructor(actual: T);
+    get not(): Matcher<T>;
+    toBe(expected: T): void;
+    toEqual(expected: T, partial?: boolean): void;
+    toMatch(expected: RegExp | string): void;
+    toMatchObject(expected: Partial<T>): void;
+    toBeNull(): void;
+    toThrow(message?: string): void;
+}
+export declare class NotMatcher<T> {
+    actual: T;
+    constructor(actual: T);
+    get not(): Matcher<T>;
+    toBe(expected: T): void;
+    toEqual(expected: T): void;
+    toMatch(expected: RegExp | string): void;
+    toMatchObject(expected: Partial<T>): void;
+    toBeNull(): void;
+    toThrow(message?: string): void;
+}
+export declare function expect<T>(t: T): Matcher<T>;

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

@@ -0,0 +1,4 @@
+/**
+ * Given a value with numbers, attempt to fix all numbers to 1 decimal point.
+ */
+export declare function fix<T>(n: T): T;

package/lib/esm/scope/index.js

@@ -0,0 +1,3 @@
+export { expect } from "./expect.js";
+export { fix } from "./fix.js";
+export { afterAll, afterEach, beforeAll, beforeEach, cleanState, describe, it, } from "./describe.js";

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

@@ -0,0 +1,17 @@
+export interface TestCase {
+    [k: string]: Function | TestCase;
+    [k: symbol]: Function;
+}
+export interface TestResult {
+    executed: number;
+    passed: number;
+    failed: number;
+    [k: string]: TestResult | TestSummary | number;
+}
+export declare type TestSummary = TestFailed | TestPassed;
+export interface TestFailed {
+    error: unknown;
+}
+export interface TestPassed {
+    passed: true;
+}

package/lib/esm/scope/scope.js

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

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

@@ -0,0 +1 @@
+export declare function cleanState<State extends {}>(init: () => State, runner: (action: () => void) => void): State;

package/lib/esm/scope/state.js

@@ -0,0 +1,7 @@
+export function cleanState(init, runner) {
+    const state = {};
+    runner(() => {
+        Object.assign(state, init());
+    });
+    return state;
+}

package/lib/esm/server/http/apps.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareFactory } from "./index.js";
+/**
+ * Searches up the request path until the first index is found.
+ */
+export declare const findIndex: MiddlewareFactory;

package/lib/esm/server/http/css.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareFactory } from "./index.js";
+/**
+ * Serves .css files statically. Finds .sass files and transpiles them to css.
+ */
+export declare const cssFileServer: MiddlewareFactory;