@davidsouther/jiffies 1.0.0 → 2.0.1

package/lib/esm/fs.d.ts

@@ -0,0 +1,48 @@
+export declare type PathLike = string;
+export interface Stats {
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+interface FileSystemAdapter {
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    copyFile(from: PathLike, to: PathLike): Promise<void>;
+    readFile(path: PathLike): Promise<string>;
+    writeFile(path: PathLike, contents: string): Promise<void>;
+    rm(path: PathLike): Promise<void>;
+}
+export declare class FileSystem implements FileSystemAdapter {
+    protected adapter: ObjectFileSystemAdapter;
+    protected wd: string;
+    protected stack: string[];
+    constructor(adapter?: ObjectFileSystemAdapter);
+    cwd(): string;
+    cd(dir: string): void;
+    pushd(dir: string): void;
+    popd(): void;
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    copyFile(from: PathLike, to: PathLike): Promise<void>;
+    readFile(path: PathLike): Promise<string>;
+    writeFile(path: PathLike, contents: string): Promise<void>;
+    rm(path: PathLike): Promise<void>;
+    private p;
+}
+export declare class ObjectFileSystemAdapter implements FileSystemAdapter {
+    private fs;
+    constructor(fs?: Record<string, string>);
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    copyFile(from: PathLike, to: PathLike): Promise<void>;
+    readFile(path: PathLike): Promise<string>;
+    writeFile(path: PathLike, contents: string): Promise<void>;
+    rm(path: PathLike): Promise<void>;
+}
+export declare class LocalStorageFileSystemAdapter extends ObjectFileSystemAdapter {
+    constructor();
+}
+export interface Tree {
+    [k: string]: string | Tree;
+}
+export declare function reset(fs: FileSystem, tree: Tree): Promise<void>;
+export {};

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

@@ -57,7 +57,7 @@ export class FileSystem {
         return this.adapter.rm(this.p(path));
     }
     p(path) {
-        return path[0] == "/" ? path : join(this.cwd(), path);
+        return path[0] === "/" ? path : join(this.cwd(), path);
     }
 }
 export class ObjectFileSystemAdapter {
@@ -88,7 +88,7 @@ export class ObjectFileSystemAdapter {
             for (const filename of Object.keys(this.fs)) {
                 if (filename.startsWith(path)) {
                     const end = filename.indexOf("/", path.length + 1);
-                    const basename = filename.substring(path.length, end == -1 ? undefined : end);
+                    const basename = filename.substring(path.length, end === -1 ? undefined : end);
                     dir.push(basename);
                 }
             }
@@ -105,7 +105,7 @@ export class ObjectFileSystemAdapter {
         return new Promise((resolve, reject) => {
             let file = this.fs[path];
             if (file === undefined) {
-                reject();
+                reject(new Error(`File Not Found ${path}`));
             }
             else {
                 resolve(file);
@@ -132,7 +132,7 @@ export class LocalStorageFileSystemAdapter extends ObjectFileSystemAdapter {
 }
 export async function reset(fs, tree) {
     for (const [path, file] of Object.entries(tree)) {
-        if (typeof file == "string") {
+        if (typeof file === "string") {
             await fs.writeFile(path, file);
         }
         else {

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

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

package/lib/esm/generator.d.ts

@@ -0,0 +1 @@
+export declare function takeWhile<T>(predicate: (t: T) => boolean, iterator: Iterable<T>): Generator<T, void, unknown>;

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

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

package/lib/esm/is_browser.d.ts

@@ -0,0 +1 @@
+export const IsBrowser: boolean;

package/lib/esm/loader.d.mts

@@ -0,0 +1,22 @@
+/** @returns {Promise<{url: string}>} */
+export function resolve(specifier: string, context: {
+    parentURL?: string;
+}, defaultResolve: (specifier: string, context: {
+    parentURL?: string;
+}, defaultResolve: Function) => Promise<{
+    url: string;
+}>): Promise<{
+    url: string;
+}>;
+/** @returns {Promise<{format: string, source: string}>} */
+export function load(url: string, context: {
+    format?: string;
+}, defaultLoad: (url: string, context: {
+    format?: string;
+}, defaultLoad?: Function) => Promise<{
+    format: string;
+    source: string;
+}>): Promise<{
+    format: string;
+    source: string;
+}>;

package/lib/esm/lock.d.ts

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

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

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

package/lib/esm/log.d.ts

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

package/lib/esm/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/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,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 {};