@davidsouther/jiffies 1.1.0 → 2.0.0

package/lib/cjs/lock.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lock = void 0;
+const locks = new WeakSet();
+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;
+        }
+    };
+}
+exports.lock = lock;

package/{build → lib/cjs}/lock.test.d.ts

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

package/lib/cjs/lock.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./scope/index.js");
+const lock_js_1 = require("./lock.js");
+(0, index_js_1.describe)("Lock", () => {
+    (0, index_js_1.it)("prevents reentry", function () {
+        let count = 0;
+        const inc = (0, lock_js_1.lock)(function () {
+            if (count > 4) {
+                return;
+            }
+            inc();
+            count++;
+        });
+        inc();
+        (0, index_js_1.expect)(count).toBe(1);
+    });
+});

package/{build → lib/cjs}/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/lib/cjs/log.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = exports.warn = exports.info = exports.debug = exports.DEFAULT_LOGGER = exports.getLogger = exports.LEVEL = void 0;
+const display_js_1 = require("./display.js");
+exports.LEVEL = {
+    UNKNOWN: 0,
+    SILENT: 0,
+    DEBUG: 1,
+    VERBOSE: 1,
+    INFO: 2,
+    WARN: 3,
+    ERROR: 4,
+};
+function getLogger(name) {
+    const logger = { level: exports.LEVEL.INFO };
+    const logAt = (level, fn) => (message, data) => level >= (logger.level ?? exports.LEVEL.SILENT)
+        ? fn((0, display_js_1.display)(message), data)
+        : undefined;
+    logger.debug = logAt(exports.LEVEL.VERBOSE, console.debug.bind(console));
+    logger.info = logAt(exports.LEVEL.INFO, console.info.bind(console));
+    logger.warn = logAt(exports.LEVEL.WARN, console.warn.bind(console));
+    logger.error = logAt(exports.LEVEL.ERROR, console.error.bind(console));
+    return logger;
+}
+exports.getLogger = getLogger;
+exports.DEFAULT_LOGGER = getLogger("default");
+function debug(message, data) {
+    if (data)
+        exports.DEFAULT_LOGGER.debug(message, data);
+    else
+        exports.DEFAULT_LOGGER.debug(message);
+}
+exports.debug = debug;
+function info(message, data) {
+    if (data)
+        exports.DEFAULT_LOGGER.info(message, data);
+    else
+        exports.DEFAULT_LOGGER.info(message);
+}
+exports.info = info;
+function warn(message, data) {
+    if (data)
+        exports.DEFAULT_LOGGER.warn(message, data);
+    else
+        exports.DEFAULT_LOGGER.warn(message);
+}
+exports.warn = warn;
+function error(message, data) {
+    if (data)
+        exports.DEFAULT_LOGGER.error(message, data);
+    else
+        exports.DEFAULT_LOGGER.error(message);
+}
+exports.error = error;

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

@@ -0,0 +1,35 @@
+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/cjs/observable/event.js

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

package/lib/cjs/observable/observable.d.ts

@@ -0,0 +1,132 @@
+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 {};