@davidsouther/jiffies 1.1.0 → 2.0.0

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

@@ -1,43 +1,43 @@
-import { FileSystem, ObjectFileSystemAdapter } from "./fs.js";
-import { describe, it, expect } from "./scope/index.js";
-describe("FileSystem", () => {
-    describe("Writing", () => {
-        it("Writes files", async () => {
-            const fsObj = {};
-            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
-            await fs.writeFile("hello", "world");
-            expect(fsObj).toEqual({ "/hello": "world" });
-        });
-        it("Writes deep files", async () => {
-            const fsObj = {};
-            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
-            await fs.writeFile("deep/hello", "world");
-            expect(fsObj).toEqual({ "/deep/hello": "world" });
-        });
-        it("Writes deep files from root", async () => {
-            const fsObj = {};
-            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
-            await fs.writeFile("/root/deep/hello", "world");
-            expect(fsObj).toEqual({ "/root/deep/hello": "world" });
-        });
-        it("Writes files after cd", async () => {
-            const fsObj = {};
-            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
-            await fs.cd("deep");
-            await fs.writeFile("hello", "world");
-            expect(fsObj).toEqual({ "/deep/hello": "world" });
-        });
-    });
-    describe("directory", () => {
-        it("returns directory listing", async () => {
-            const fsObj = {
-                "/deep/hello": "world",
-                "/deep/bonjour": "monde",
-                "/other/file": "text",
-            };
-            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
-            const dir = await fs.readdir("deep");
-            expect(dir.sort()).toEqual(["bonjour", "hello"]);
-        });
-    });
-});
+import { FileSystem, ObjectFileSystemAdapter } from "./fs.js";
+import { describe, it, expect } from "./scope/index.js";
+describe("FileSystem", () => {
+    describe("Writing", () => {
+        it("Writes files", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("hello", "world");
+            expect(fsObj).toEqual({ "/hello": "world" });
+        });
+        it("Writes deep files", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("deep/hello", "world");
+            expect(fsObj).toEqual({ "/deep/hello": "world" });
+        });
+        it("Writes deep files from root", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("/root/deep/hello", "world");
+            expect(fsObj).toEqual({ "/root/deep/hello": "world" });
+        });
+        it("Writes files after cd", async () => {
+            const fsObj = {};
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            await fs.cd("deep");
+            await fs.writeFile("hello", "world");
+            expect(fsObj).toEqual({ "/deep/hello": "world" });
+        });
+    });
+    describe("directory", () => {
+        it("returns directory listing", async () => {
+            const fsObj = {
+                "/deep/hello": "world",
+                "/deep/bonjour": "monde",
+                "/other/file": "text",
+            };
+            const fs = new FileSystem(new ObjectFileSystemAdapter(fsObj));
+            const dir = await fs.readdir("deep");
+            expect(dir.sort()).toEqual(["bonjour", "hello"]);
+        });
+    });
+});

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/{build → lib/esm}/generator.js

@@ -1,10 +1,10 @@
-export function* takeWhile(predicate, iterator) {
-    for (const x of iterator) {
-        if (predicate(x)) {
-            yield x;
-        }
-        else {
-            return;
-        }
-    }
-}
+export function* takeWhile(predicate, iterator) {
+    for (const x of iterator) {
+        if (predicate(x)) {
+            yield x;
+        }
+        else {
+            return;
+        }
+    }
+}

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

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

package/{build → lib/esm}/generator.test.js

@@ -1,24 +1,24 @@
-import { takeWhile } from "./generator.js";
-import { describe, it, expect } from "./scope/index.js";
-describe("Generator", () => {
-    it("takes from a generator until a predicate", () => {
-        const generator = function* () {
-            let i = 1;
-            while (true) {
-                yield (i = i * 2);
-            }
-        };
-        const filter = () => {
-            let previousValue = 0;
-            return (n) => {
-                if (previousValue < 100) {
-                    previousValue = n;
-                    return true;
-                }
-                return false;
-            };
-        };
-        const values = [...takeWhile(filter(), generator())];
-        expect(values).toEqual([2, 4, 8, 16, 32, 64, 128]);
-    });
-});
+import { takeWhile } from "./generator.js";
+import { describe, it, expect } from "./scope/index.js";
+describe("Generator", () => {
+    it("takes from a generator until a predicate", () => {
+        const generator = function* () {
+            let i = 1;
+            while (true) {
+                yield (i = i * 2);
+            }
+        };
+        const filter = () => {
+            let previousValue = 0;
+            return (n) => {
+                if (previousValue < 100) {
+                    previousValue = n;
+                    return true;
+                }
+                return false;
+            };
+        };
+        const values = [...takeWhile(filter(), generator())];
+        expect(values).toEqual([2, 4, 8, 16, 32, 64, 128]);
+    });
+});

package/lib/esm/is_browser.d.ts

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

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

@@ -1 +1 @@
-export const IsBrowser = typeof window !== "undefined";
+export const IsBrowser = typeof window !== "undefined";

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/{build → lib/esm}/loader.mjs

@@ -1,35 +1,35 @@
-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}>} */
-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 };
-        }
-    }
-    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);
-}
+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}>} */
+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 };
+        }
+    }
+    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

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

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

@@ -1,23 +1,23 @@
-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;
-        }
-    };
-}
+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

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

package/{build → lib/esm}/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/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/{build → lib/esm}/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/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;
+};