@davidsouther/jiffies 1.0.0 → 1.1.0

package/build/lock.test.js

@@ -1,16 +1,16 @@
-import { describe, it, expect } from "./scope/index.js";
-import { lock } from "./lock.js";
-describe("Lock", () => {
-    it("prevents reentry", function () {
-        let count = 0;
-        const inc = lock(function () {
-            if (count > 4) {
-                return;
-            }
-            inc();
-            count++;
-        });
-        inc();
-        expect(count).toBe(1);
-    });
-});
+import { describe, it, expect } from "./scope/index.js";
+import { lock } from "./lock.js";
+describe("Lock", () => {
+    it("prevents reentry", function () {
+        let count = 0;
+        const inc = lock(function () {
+            if (count > 4) {
+                return;
+            }
+            inc();
+            count++;
+        });
+        inc();
+        expect(count).toBe(1);
+    });
+});

package/build/log.d.ts

@@ -1,26 +1,26 @@
-import { Display } from "./display.js";
-export interface Log {
-    (message: Display, data?: {}): void;
-}
-export interface Logger {
-    level: Number;
-    debug: Log;
-    info: Log;
-    warn: Log;
-    error: Log;
-}
-export declare const LEVEL: {
-    UNKNOWN: number;
-    SILENT: number;
-    DEBUG: number;
-    VERBOSE: number;
-    INFO: number;
-    WARN: number;
-    ERROR: number;
-};
-export declare function getLogger(name: string): Logger;
-export declare const DEFAULT_LOGGER: Logger;
-export declare function debug(message: Display, data?: {}): void;
-export declare function info(message: Display, data?: {}): void;
-export declare function warn(message: Display, data?: {}): void;
-export declare function error(message: Display, data?: {}): void;
+import { Display } from "./display.js";
+export interface Log {
+    (message: Display, data?: {}): void;
+}
+export interface Logger {
+    level: Number;
+    debug: Log;
+    info: Log;
+    warn: Log;
+    error: Log;
+}
+export declare const LEVEL: {
+    UNKNOWN: number;
+    SILENT: number;
+    DEBUG: number;
+    VERBOSE: number;
+    INFO: number;
+    WARN: number;
+    ERROR: number;
+};
+export declare function getLogger(name: string): Logger;
+export declare const DEFAULT_LOGGER: Logger;
+export declare function debug(message: Display, data?: {}): void;
+export declare function info(message: Display, data?: {}): void;
+export declare function warn(message: Display, data?: {}): void;
+export declare function error(message: Display, data?: {}): void;

package/build/log.js

@@ -1,46 +1,46 @@
-import { display } from "./display.js";
-export const LEVEL = {
-    UNKNOWN: 0,
-    SILENT: 0,
-    DEBUG: 1,
-    VERBOSE: 1,
-    INFO: 2,
-    WARN: 3,
-    ERROR: 4,
-};
-export function getLogger(name) {
-    const logger = { level: LEVEL.INFO };
-    const logAt = (level, fn) => (message, data) => level >= (logger.level ?? LEVEL.SILENT)
-        ? fn(display(message), data)
-        : undefined;
-    logger.debug = logAt(LEVEL.VERBOSE, console.debug.bind(console));
-    logger.info = logAt(LEVEL.INFO, console.info.bind(console));
-    logger.warn = logAt(LEVEL.WARN, console.warn.bind(console));
-    logger.error = logAt(LEVEL.ERROR, console.error.bind(console));
-    return logger;
-}
-export const DEFAULT_LOGGER = getLogger("default");
-export function debug(message, data) {
-    if (data)
-        DEFAULT_LOGGER.debug(message, data);
-    else
-        DEFAULT_LOGGER.debug(message);
-}
-export function info(message, data) {
-    if (data)
-        DEFAULT_LOGGER.info(message, data);
-    else
-        DEFAULT_LOGGER.info(message);
-}
-export function warn(message, data) {
-    if (data)
-        DEFAULT_LOGGER.warn(message, data);
-    else
-        DEFAULT_LOGGER.warn(message);
-}
-export function error(message, data) {
-    if (data)
-        DEFAULT_LOGGER.error(message, data);
-    else
-        DEFAULT_LOGGER.error(message);
-}
+import { display } from "./display.js";
+export const LEVEL = {
+    UNKNOWN: 0,
+    SILENT: 0,
+    DEBUG: 1,
+    VERBOSE: 1,
+    INFO: 2,
+    WARN: 3,
+    ERROR: 4,
+};
+export function getLogger(name) {
+    const logger = { level: LEVEL.INFO };
+    const logAt = (level, fn) => (message, data) => level >= (logger.level ?? LEVEL.SILENT)
+        ? fn(display(message), data)
+        : undefined;
+    logger.debug = logAt(LEVEL.VERBOSE, console.debug.bind(console));
+    logger.info = logAt(LEVEL.INFO, console.info.bind(console));
+    logger.warn = logAt(LEVEL.WARN, console.warn.bind(console));
+    logger.error = logAt(LEVEL.ERROR, console.error.bind(console));
+    return logger;
+}
+export const DEFAULT_LOGGER = getLogger("default");
+export function debug(message, data) {
+    if (data)
+        DEFAULT_LOGGER.debug(message, data);
+    else
+        DEFAULT_LOGGER.debug(message);
+}
+export function info(message, data) {
+    if (data)
+        DEFAULT_LOGGER.info(message, data);
+    else
+        DEFAULT_LOGGER.info(message);
+}
+export function warn(message, data) {
+    if (data)
+        DEFAULT_LOGGER.warn(message, data);
+    else
+        DEFAULT_LOGGER.warn(message);
+}
+export function error(message, data) {
+    if (data)
+        DEFAULT_LOGGER.error(message, data);
+    else
+        DEFAULT_LOGGER.error(message);
+}

package/build/observable/observable.d.ts

@@ -0,0 +1,83 @@
+import { Logger } from "../log.js";
+export interface Subscriber<T, E> {
+    next?: (t: T) => void | Promise<undefined>;
+    error?: (e: E) => void | Promise<undefined>;
+    complete?: () => void | Promise<undefined>;
+}
+export interface Subscription {
+    unsubscribe(): void;
+}
+export interface Observable<T, E = unknown> {
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+    pipe<T1>(o1: (t: T) => T1): Observable<T1, E>;
+    pipe<T1, T2>(o1: (t: T) => T1, o2: (t: T) => T2): Observable<T2, E>;
+    pipe<T1, T2, T3>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3): Observable<T3, E>;
+    pipe<T1, T2, T3, T4>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4): Observable<T4, E>;
+    pipe<T1, T2, T3, T4, T5>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4, o5: (t: T4) => T5): Observable<T5, E>;
+}
+export declare const Observable: {
+    of<T, E>(...T: T[]): void;
+    combineLatest<T_1, E_1>(...O: Observable<T_1, E_1>[]): void;
+    from<T_2, E_2>(f: Promise<T_2> | Iterable<T_2> | Observable<T_2, E_2>): void;
+    fromEvent<T_3, E_3>(element: {
+        addEventListener<Ev>(fn: (e: Ev) => void): void;
+    }, eventName: string): void;
+};
+export declare class Subject<T, E = unknown> implements Subscriber<T, E>, Observable<T, E> {
+    #private;
+    next(t: T): Promise<undefined>;
+    error(e: E): Promise<undefined>;
+    complete(): Promise<undefined>;
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+    pipe<T1>(o1: (t: T) => T1): Observable<T1, E>;
+    pipe<T1, T2>(o1: (t: T) => T1, o2: (t: T1) => T2): Observable<T2, E>;
+    pipe<T1, T2, T3>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3): Observable<T3, E>;
+    pipe<T1, T2, T3, T4>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4): Observable<T4, E>;
+    pipe<T1, T2, T3, T4, T5>(o1: (t: T) => T1, o2: (t: T1) => T2, o3: (t: T2) => T3, o4: (t: T3) => T4, o5: (t: T4) => T5): Observable<T5, E>;
+}
+export declare class BehaviorSubject<T, E = unknown> extends Subject<T, E> {
+    #private;
+    constructor(t: T);
+    next(t: T): 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);
+    next(t: T): Promise<undefined>;
+    subscribe(subscriber: Subscriber<T, E>): Subscription;
+}
+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 declare type Event<T, E> = Next<T> | Error<E> | Completed | Failed;
+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>[];
+export declare const watch: <T, E>(logger?: Logger) => (observable: Observable<T, E>) => void;

package/build/observable/observable.js

@@ -0,0 +1,148 @@
+import { display } from "../display.js";
+import { DEFAULT_LOGGER } from "../log.js";
+export const Observable = {
+    of(...T) { },
+    combineLatest(...O) { },
+    from(f) { },
+    fromEvent(element, eventName) { },
+};
+export class Subject {
+    #subscribers = new Set();
+    #complete = false;
+    async next(t) {
+        if (this.#complete)
+            throw new Error("Cannot call next on a completed subject");
+        await Promise.all([...this.#subscribers].map((s) => s.next?.(t)));
+        return;
+    }
+    async error(e) {
+        if (this.#complete)
+            throw new Error("Cannot call error on a completed subject");
+        await Promise.all([...this.#subscribers].map((s) => s.error?.(e)));
+        return;
+    }
+    async complete() {
+        if (this.#complete)
+            throw new Error("Cannot call complete on a completed subject");
+        this.#complete = true;
+        const finished = Promise.all([...this.#subscribers].map((s) => s.complete?.()));
+        this.#subscribers.clear(); // Free subscribers for garbage collection
+        await finished;
+        return;
+    }
+    subscribe(subscriber) {
+        if (this.#complete)
+            throw new Error("Cannot call subscribe on a completed subject");
+        this.#subscribers.add(subscriber);
+        return { unsubscribe: () => this.#subscribers.delete(subscriber) };
+    }
+    pipe(o1, o2, o3, o4, o5) {
+        let o = o1.subscribe(this);
+    }
+}
+export class BehaviorSubject extends Subject {
+    #current;
+    constructor(t) {
+        super();
+        this.#current = t;
+    }
+    next(t) {
+        this.#current = t;
+        return super.next(t);
+    }
+    subscribe(subscriber) {
+        subscriber.next?.(this.#current);
+        return super.subscribe(subscriber);
+    }
+    get current() {
+        return this.#current;
+    }
+}
+export class ReplaySubject extends Subject {
+    n;
+    #history = [];
+    constructor(n) {
+        super();
+        this.n = n;
+    }
+    next(t) {
+        this.#history.push(t);
+        if (this.#history.length > this.n) {
+            this.#history.shift();
+        }
+        return super.next(t);
+    }
+    subscribe(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);
+    }
+}
+const operator = {
+    filter(fn) { },
+    first() { },
+    last() { },
+    map: (fn) => ({}),
+    publishReplay(n) { },
+    reduce(fn) { },
+    takeUntil(o) { },
+    tap(fn) { },
+};
+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;
+};
+export const watch = (logger = DEFAULT_LOGGER) => (observable) => {
+    observable.pipe(operator.tap({
+        next(t) {
+            logger.info(t);
+        },
+        complete() {
+            logger.info("Observable completed");
+        },
+        error(e) {
+            logger.warn(e);
+        },
+    }));
+};

package/build/observable/observable.test.d.ts

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

package/build/observable/observable.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "../scope/index.js";
+import { Subject } 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", () => { });
+    describe("pipes", () => { });
+    describe("subjects", () => { });
+});

package/build/range.d.ts

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

package/build/range.js

@@ -1,7 +1,7 @@
-export function range(start, end, stride = 1) {
-    const range = [];
-    for (let i = start; i < end; i += stride) {
-        range.push(i);
-    }
-    return range;
-}
+export function range(start, end, stride = 1) {
+    const range = [];
+    for (let i = start; i < end; i += stride) {
+        range.push(i);
+    }
+    return range;
+}

package/build/result.d.ts

@@ -1,31 +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;
+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/result.js

@@ -1,65 +1,65 @@
-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.ok !== undefined;
-export const isErr = (e) => e.err !== undefined;
-export const isResult = (t) => isOk(t) || isErr(t);
-export function Ok(t) {
-    return t.ok
-        ? 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;
-}
+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.ok !== undefined;
+export const isErr = (e) => e.err !== undefined;
+export const isResult = (t) => isOk(t) || isErr(t);
+export function Ok(t) {
+    return t.ok
+        ? 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/build/result.test.d.ts

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