@davidsouther/jiffies 2026.24.0 → 2026.24.2

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

@@ -0,0 +1,35 @@
+import type { Observable } from "./observable.ts";
+export interface Next<T> {
+    value: T;
+    completed: false;
+    failed: false;
+}
+export interface Error<E> {
+    error: E;
+    completed: false;
+    failed: true;
+}
+export interface Completed {
+    completed: true;
+    failed: false;
+}
+export interface Failed {
+    completed: true;
+    failed: true;
+}
+export type Event<T, E> = Next<T> | Error<E> | Completed | Failed;
+export interface EventSubscriber<T, E> {
+    next(e: Event<T, E>): void;
+}
+export declare const next: <T>(value: T) => Next<T>;
+export declare const error: <E>(e: E) => Error<E>;
+export declare const completed: () => Completed;
+export declare const failed: () => Failed;
+export declare const isNext: <T>(event: Event<T, unknown>) => event is Next<T>;
+export declare const isError: <E>(event: Event<unknown, E>) => event is Error<E>;
+export declare const isCompleted: (event: Event<unknown, unknown>) => event is Completed;
+export declare const isFailed: (event: Event<unknown, unknown>) => event is Failed;
+export declare const isEvent: <T, E>(t: T | Event<T, E>) => t is Event<T, E>;
+export declare const asEvents: <T, E>(a: (T | Event<T, E>)[]) => Event<T, E>[];
+export declare const marbles: <T, E>(events: Event<T, E>[]) => string;
+export declare const collect: <T, E>(input$: Observable<T, E>) => Event<T, E>[];

package/lib/esm/observable/event.js

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

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

@@ -0,0 +1,134 @@
+import type { Display } from "../display.ts";
+import { type Logger } from "../log.ts";
+export interface FullSubscriber<T, E> {
+    next?: (t: T) => void | Promise<void>;
+    error?: (e: E) => void | Promise<void>;
+    complete?: () => void | Promise<void>;
+}
+export type Subscriber<T, E> = FullSubscriber<T, E> | ((t: T) => void | Promise<void>);
+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>(o1: Observable<T1, E>, o2: Observable<T2, E>): Observable<[T1, T2], E>;
+};
+interface Scheduler {
+    execute(fn: () => (void | Promise<void>)[]): void | Promise<void>;
+}
+export declare const AsyncScheduler: Scheduler;
+export declare const SyncScheduler: Scheduler;
+export declare function setDefaultScheduler(scheduler: Scheduler): void;
+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: CallableFunction): void;
+    next(t: T | T2): void | Promise<void>;
+    error(e: E): void | Promise<void>;
+    complete(): void | Promise<void>;
+    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<void>;
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+    get current(): T;
+}
+export declare class ReplaySubject<T, E = unknown> extends Subject<T, E> {
+    #private;
+    readonly n: number;
+    constructor(n: number, scheduler?: Scheduler);
+    next(t: T): void | Promise<void>;
+    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> {
+    eventFn: (e: E) => void | Promise<void>;
+    constructor(eventFn: (e: E) => void | Promise<void>);
+    next(e: E): Promise<undefined>;
+}
+export declare const watch: <T extends Display, E extends Display>(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<void>;
+}
+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<void>;
+}
+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<void>;
+}
+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<void>;
+}
+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<void>;
+    error(e: E): void | Promise<void>;
+    complete(): void | Promise<void>;
+}
+declare class FirstOperator<T, E> extends Subject<T, E> {
+    next(t: T): void | Promise<void>;
+}
+declare class LastOperator<T, E = Error> extends Subject<T, E> {
+    #private;
+    next(t: T): void;
+    complete(): void | Promise<void>;
+}
+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) => 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, E>(fn?: (t1: T, t2: T) => boolean) => DistinctOperator<T, E>;
+    first: <T, E>() => FirstOperator<T, E>;
+    last: <T, E>() => LastOperator<T, E>;
+    map: <T1, T2, E>(fn: (t: T1) => T2) => MapOperator<T1, T2, E>;
+    replay: <T, E>(n: number) => ReplaySubject<T, E>;
+    reduce: <A, T, E>(fn: (acc: A, t: T) => A, init: A) => ReduceOperator<A, T, E>;
+    takeUntil: <T, E>(o: Observable<unknown, unknown>) => TakeUntilOperator<T, E>;
+    tap: <T, E>(fn: Subscriber<T, E>) => TapOperator<T, E>;
+};
+export {};

package/lib/esm/observable/observable.js

@@ -0,0 +1,349 @@
+import { assertExists } from "../assert.js";
+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 = assertExists(ts.shift());
+            await subject.next(t);
+            next();
+        })();
+        return subject;
+    },
+    combineLatest(o1, o2) {
+        const 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();
+        }
+        const o1sub = o1.subscribe({
+            next(t) {
+                o1Latest = t;
+                o1LatestSet = true;
+                next();
+            },
+            error,
+            complete,
+        });
+        const 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();
+    },
+};
+let DefaultScheduler = SyncScheduler;
+export function setDefaultScheduler(scheduler) {
+    DefaultScheduler = scheduler;
+}
+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 = DefaultScheduler) {
+        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);
+        for (const w of this.#coldWaiters)
+            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 ?? AsyncScheduler);
+        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 ?? SyncScheduler);
+        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 = assertExists(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(AsyncScheduler);
+        this.eventFn = eventFn;
+    }
+    async next(e) {
+        e.preventDefault();
+        super.next(e);
+    }
+}
+export const watch = (logger = DEFAULT_LOGGER) => (observable) => {
+    observable.tap({
+        async next(t) {
+            logger.info(t);
+        },
+        async complete() {
+            logger.info("Observable completed");
+        },
+        async error(e) {
+            logger.warn(e);
+        },
+    });
+};
+class MapOperator extends Subject {
+    mapFn;
+    constructor(mapFn) {
+        super(SyncScheduler);
+        this.mapFn = mapFn;
+    }
+    next(t) {
+        return super.next(this.mapFn(t));
+    }
+}
+class FilterOperator extends Subject {
+    filterFn;
+    constructor(filterFn) {
+        super(SyncScheduler);
+        this.filterFn = filterFn;
+    }
+    next(t) {
+        return this.filterFn(t) ? super.next(t) : undefined;
+    }
+}
+class DistinctOperator extends Subject {
+    #prior = undefined;
+    distinctFn;
+    constructor(distinctFn = Object.is) {
+        super(SyncScheduler);
+        this.distinctFn = distinctFn;
+    }
+    next(t) {
+        if (this.#prior === undefined) {
+            this.#prior = t;
+            return super.next(t);
+        }
+        const same = this.distinctFn(assertExists(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/range.d.ts

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

package/lib/esm/range.js

@@ -0,0 +1,7 @@
+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 const isNone: <T>(s: Option<T>) => s is None;
+export declare const isSome: <T>(s: Option<T>) => s is Some<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, _E = unknown>(ok: Ok<T>): T;
+export declare function Ok<T, _E = unknown>(t?: T): Ok<T>;
+export declare function Err<_T, E>(e: Err<E>): E;
+export declare function Err<_T, E>(e: E): Err<E>;
+export declare function Err<_T, 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, E>, def: () => T): T;
+export declare function unwrapOrElse<T, _E>(some: Some<T>, def: () => T): T;
+export type None = null;
+export type Some<T> = T;
+export type Option<T> = Some<T> | None;
+export type Err<E = Error> = {
+    err: E;
+    map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
+};
+export type Ok<T> = {
+    ok: T;
+    map: <U>(fn: (t: T) => Result<U>) => Result<U>;
+};
+export type Result<T, E = Error> = Ok<T> | Err<E>;

package/lib/esm/result.js

@@ -0,0 +1,66 @@
+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) => t && Object.hasOwn(t, "ok");
+export const isErr = (e) => e && Object.hasOwn(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/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/safe.js

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

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

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