@davidsouther/jiffies 2.2.5 → 2026.4.0

package/lib/esm/loader.mjs

@@ -1,36 +0,0 @@
-import { stat } from "node:fs/promises";
-import { cwd } from "node:process";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { transpile } from "./transpile.mjs";
-const baseURL = pathToFileURL(`${cwd()}/`).href;
-/** @returns {Promise<{url: string, shortCircuit?: boolean}>} */
-export async function resolve(
-/** @type string */ specifier, 
-/** @type {{parentURL?: string}} */ context, 
-/** @type {(specifier: string, context: {parentURL?: string}, defaultResolve: Function) => Promise<{url: string}>} */ defaultResolve) {
-    const tsURL = new URL(specifier.replace(/js$/, "ts"), context.parentURL ?? baseURL);
-    const tsSpecifier = tsURL.href;
-    try {
-        const stats = await stat(fileURLToPath(tsURL));
-        if (stats.isFile()) {
-            // return { url: tsSpecifier, shortCircuit: true };
-            return defaultResolve(tsSpecifier, context, defaultResolve);
-        }
-    }
-    catch (e) {
-        // Do nothing
-    }
-    return defaultResolve(specifier, context, defaultResolve);
-}
-/** @returns {Promise<{format: string, source: string}>} */
-export async function load(
-/** @type string */ url, 
-/** @type {{format?: string}} */ context, 
-/** @type {(url: string, context: {format?: string}, defaultLoad?: Function) => Promise<{format: string, source: string}>} */ defaultLoad) {
-    return url.endsWith("ts")
-        ? {
-            format: "module",
-            source: await transpile(url, async () => (await defaultLoad(url, { format: "module" })).source),
-        }
-        : defaultLoad(url, context, defaultLoad);
-}

package/lib/esm/lock.d.ts

@@ -1 +0,0 @@
-export declare function lock(fn: Function): Function;

package/lib/esm/lock.js

@@ -1,23 +0,0 @@
-const locks = new WeakSet();
-export function lock(fn) {
-    return function (...args) {
-        let ret = null;
-        let ex = null;
-        if (!locks.has(fn)) {
-            locks.add(fn);
-            try {
-                ret = fn(...args);
-            }
-            catch (e) {
-                ex = e;
-            }
-        }
-        locks.delete(fn);
-        if (ex !== null) {
-            throw ex;
-        }
-        else {
-            return ret;
-        }
-    };
-}

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

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

package/lib/esm/lock.test.js

@@ -1,16 +0,0 @@
-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/lib/esm/log.d.ts

@@ -1,56 +0,0 @@
-import { Display } from "./display.js";
-export interface Log {
-    (message: Display, data?: {}): void;
-}
-export interface Logger {
-    logAt: (level: number, prefix: string, fn?: (logLine: string) => void) => Log;
-    level: number;
-    format: <D extends {
-        name: string;
-        prefix: string;
-        level: number;
-        message: string;
-        source: string;
-    }>(data: D) => string;
-    console: Console;
-    default: (logLine: string) => void;
-    debug: Log;
-    info: Log;
-    warn: Log;
-    error: Log;
-}
-export declare const LEVEL: {
-    UNKNOWN: number;
-    DEBUG: number;
-    VERBOSE: number;
-    INFO: number;
-    WARN: number;
-    ERROR: number;
-    SILENT: number;
-};
-export declare const LEVELS: Record<string, number>;
-export declare function getLogLevel(level?: string): number;
-export declare function basicLogFormatter(data: {
-    name: string;
-    prefix: string;
-    level: number;
-    message: string;
-    source: string;
-}): string;
-declare type LoggerFormatFn = <D extends {
-    name: string;
-    prefix: string;
-    level: number;
-    message: string;
-    source: string;
-}>(data: D) => string;
-export declare function getLogger(name: string, args?: LoggerFormatFn | {
-    format?: LoggerFormatFn;
-    console?: Console;
-}): 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;
-export {};

package/lib/esm/log.js

@@ -1,93 +0,0 @@
-import { display } from "./display.js";
-export const LEVEL = {
-    UNKNOWN: 2,
-    DEBUG: 1,
-    VERBOSE: 1,
-    INFO: 2,
-    WARN: 3,
-    ERROR: 4,
-    SILENT: 5,
-};
-export const LEVELS = {
-    unknown: LEVEL.UNKNOWN,
-    debug: LEVEL.DEBUG,
-    verbose: LEVEL.VERBOSE,
-    info: LEVEL.INFO,
-    warn: LEVEL.WARN,
-    error: LEVEL.ERROR,
-    silent: LEVEL.SILENT,
-};
-export function getLogLevel(level = "") {
-    return (LEVELS[level.toLowerCase()] ?? (!isNaN(+level) ? Number(level) : LEVEL.INFO));
-}
-export function basicLogFormatter(data) {
-    return `${data.prefix}: ${data.message}`;
-}
-function findSource() {
-    const err = new Error();
-    // Stack will be:
-    // findSource
-    // logAt
-    // {source}
-    const lines = err.stack?.split("\n") ?? [];
-    const atLines = lines.filter((line) => line.match(/^\s*at/));
-    return atLines[2]?.trim().slice("at ".length) ?? "(unknown)";
-}
-export function getLogger(name, args = {
-    format: JSON.stringify,
-    console,
-}) {
-    if (args instanceof Function) {
-        args = { format: args };
-    }
-    const defaultLog = (logLine) => {
-        logger.console.info(logLine);
-    };
-    const logAt = (level, prefix, fn = defaultLog) => (message, data) => level >= (logger.level ?? LEVEL.SILENT)
-        ? fn(logger.format({
-            name,
-            prefix,
-            level,
-            message: display(message),
-            ...data,
-            source: findSource(),
-        }))
-        : undefined;
-    const logger = {
-        logAt,
-        default: defaultLog,
-        level: LEVEL.INFO,
-        format: args.format ?? JSON.stringify,
-        console: args.console ?? global.console,
-        debug: logAt(LEVEL.DEBUG, "DEBUG", (l) => logger.console.debug(l)),
-        info: logAt(LEVEL.INFO, "INFO", (l) => logger.console.info(l)),
-        warn: logAt(LEVEL.WARN, "WARN", (l) => logger.console.warn(l)),
-        error: logAt(LEVEL.ERROR, "ERR", (l) => logger.console.error(l)),
-    };
-    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/lib/esm/observable/event.d.ts

@@ -1,35 +0,0 @@
-import { Observable } from "./observable.js";
-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 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

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

@@ -1,132 +0,0 @@
-import { Logger } from "../log.js";
-export interface FullSubscriber<T, E> {
-    next?: (t: T) => void | Promise<undefined>;
-    error?: (e: E) => void | Promise<undefined>;
-    complete?: () => void | Promise<undefined>;
-}
-export declare type Subscriber<T, E> = FullSubscriber<T, E> | ((t: T) => void | Promise<undefined>);
-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_1>(o1: Observable<T1, E_1>, o2: Observable<T2, E_1>): Observable<[T1, T2], E_1>;
-};
-interface Scheduler {
-    execute(fn: () => (void | Promise<undefined>)[]): void | Promise<undefined>;
-}
-export declare const AsyncScheduler: Scheduler;
-export declare const SyncScheduler: Scheduler;
-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: Function): void;
-    next(t: T | T2): void | Promise<undefined>;
-    error(e: E): void | Promise<undefined>;
-    complete(): void | Promise<undefined>;
-    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<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, scheduler?: Scheduler);
-    next(t: T): void | Promise<undefined>;
-    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> {
-    private readonly eventFn;
-    constructor(eventFn: (e: E) => void | Promise<undefined>);
-    next(e: E): void;
-}
-export declare const watch: <T, E>(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<undefined>;
-}
-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<undefined>;
-}
-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<undefined>;
-}
-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<undefined>;
-}
-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<undefined>;
-    error(e: E): void | Promise<undefined>;
-    complete(): void | Promise<undefined>;
-}
-declare class FirstOperator<T, E> extends Subject<T, E> {
-    next(t: T): void | Promise<undefined>;
-}
-declare class LastOperator<T, E = Error> extends Subject<T, E> {
-    #private;
-    next(t: T): void;
-    complete(): void | Promise<undefined>;
-}
-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) | undefined) => 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_1, E_1>(fn?: ((t1: T_1, t2: T_1) => boolean) | undefined) => DistinctOperator<T_1, E_1>;
-    first: <T_2, E_2>() => FirstOperator<T_2, E_2>;
-    last: <T_3, E_3>() => LastOperator<T_3, E_3>;
-    map: <T1, T2, E_4>(fn: (t: T1) => T2) => MapOperator<T1, T2, E_4>;
-    replay: <T_4, E_5>(n: number) => ReplaySubject<T_4, E_5>;
-    reduce: <A, T_5, E_6>(fn: (acc: A, t: T_5) => A, init: A) => ReduceOperator<A, T_5, E_6>;
-    takeUntil: <T_6, E_7>(o: Observable<unknown, unknown>) => TakeUntilOperator<T_6, E_7>;
-    tap: <T_7, E_8>(fn: Subscriber<T_7, E_8>) => TapOperator<T_7, E_8>;
-};
-export {};