@davidsouther/jiffies 1.0.0 → 2.0.1

package/lib/cjs/dom/types/css.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+https://github.com/frenic/csstype v3.0.11
+Copyright (c) 2017-2018 Fredrik Nicol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/{build → lib/cjs}/dom/types/html.d.ts

@@ -1,4 +1,4 @@
-import { Properties } from "./css.js";
+import { Properties } from "./css";
 export interface AriaAttributes {
     [_: `aria-${string}`]: string;
 }

package/lib/cjs/dom/types/html.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/dom/xml.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xml = void 0;
+function xml(tag, attributes, children = []) {
+    const attrs = Object.entries(attributes).reduce((attrs, [attr, val]) => `${attrs} ${attr}="${val}"`, "");
+    return `<${tag} ${attrs}>${children.join("")}</${tag}>`;
+}
+exports.xml = xml;

package/lib/cjs/equal.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equals = exports.matchObjects = exports.matchArrays = exports.equalArrays = exports.compareArrays = void 0;
+function compareArrays(equal) {
+    return (a, b, partial = false) => a.length === b.length && a.every((e, i) => equal(e, b[i], partial));
+}
+exports.compareArrays = compareArrays;
+exports.equalArrays = compareArrays(Object.is);
+exports.matchArrays = compareArrays(equals);
+function asArray(a) {
+    return Object.entries(a).sort((a, b) => a[0].localeCompare(b[0]));
+}
+const matchObjects = (a, b, partial = true) => {
+    for (const [k, v] of Object.entries(a)) {
+        if (!b.hasOwnProperty(k) && partial)
+            continue;
+        // @ts-ignore
+        if (!equals(v, b[k], partial))
+            return false;
+    }
+    return true;
+};
+exports.matchObjects = matchObjects;
+function equals(a, b, partial = false) {
+    // runtime type checking
+    switch (typeof a) {
+        case "object":
+            if (b === undefined) {
+                return false;
+            }
+            if (a instanceof Array && b instanceof Array) {
+                return (0, exports.matchArrays)(a, b, partial);
+            }
+            else {
+                return (0, exports.matchObjects)(a, b, partial);
+            }
+        case "function":
+            return a.name === b.name;
+        default:
+            return Object.is(a, b);
+    }
+}
+exports.equals = equals;

package/lib/cjs/equal.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./scope/index.js");
+const equal_js_1 = require("./equal.js");
+(0, index_js_1.describe)("Equality", () => {
+    (0, index_js_1.it)("compares objects", () => {
+        (0, index_js_1.expect)((0, equal_js_1.equals)({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true);
+        (0, index_js_1.expect)((0, equal_js_1.equals)({ a: 1, b: 2 }, { b: 1, a: 2 })).toBe(false);
+    });
+    (0, index_js_1.it)("compares primitives", () => {
+        (0, index_js_1.expect)((0, equal_js_1.equals)(1, 1)).toBe(true);
+        (0, index_js_1.expect)((0, equal_js_1.equals)(1, -1)).toBe(false);
+        (0, index_js_1.expect)((0, equal_js_1.equals)(0, -0)).toBe(false);
+        (0, index_js_1.expect)((0, equal_js_1.equals)(NaN, NaN)).toBe(true);
+    });
+    (0, index_js_1.it)("compares arrays", () => {
+        (0, index_js_1.expect)((0, equal_js_1.equalArrays)([1, 2, 3], [1, 2, 3])).toBe(true);
+        (0, index_js_1.expect)((0, equal_js_1.equalArrays)([1], [2, 3])).toBe(false);
+        (0, index_js_1.expect)((0, equal_js_1.equalArrays)([{ a: 1 }], [{ a: 1 }])).toBe(false);
+        (0, index_js_1.expect)((0, equal_js_1.matchArrays)([{ a: 1 }], [{ a: 1 }])).toBe(true);
+    });
+});

package/lib/cjs/flags.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const parse = (parseArgs) => {
+    const fromNode = parseArgs[0].endsWith("node");
+    const argv = parseArgs[fromNode ? 1 : 0];
+    const params = new Map();
+    const flags = new Map();
+    const args = [];
+    let index = fromNode ? 2 : 1;
+    const hasNext = () => index < parseArgs.length;
+    const peek = () => parseArgs[index];
+    const advance = () => parseArgs[index++];
+    const parseLong = (arg) => {
+        if (arg.substr(0, 3) === "no-") {
+            flags.set(arg.substr(3), false);
+        }
+        else if (!arg.includes("=")) {
+            flags.set(arg, true);
+        }
+        else {
+            const [param, ...value] = arg.split("=");
+            params.set(param, value.join("="));
+        }
+    };
+    while (hasNext()) {
+        if (peek().substr(0, 2) === "--") {
+            parseLong(advance().substr(2));
+        }
+        else {
+            args.push(advance());
+        }
+    }
+    return {
+        get argv0() {
+            return argv;
+        },
+        get args() {
+            return args;
+        },
+        get(flag, def = false) {
+            return flags.get(flag) ?? def;
+        },
+        asNumber(param, def = 0) {
+            return Number.parseFloat(params.get(param) ?? `${def}`);
+        },
+        asString(param, def = "") {
+            return params.get(param) ?? def;
+        },
+    };
+};
+exports.parse = parse;

package/lib/cjs/flags.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./scope/index.js");
+const flags_js_1 = require("./flags.js");
+const TEST_CASES = {
+    SIMPLE: "program",
+    NODE: "/usr/local/bin/node program",
+    ONE_FLAG: "program --fun",
+    ONE_PARAM: "program --fun=100",
+    ONE_ARG: "program cat",
+    ONE_NO_FLAG: "program --no-fun",
+    MIXED: "program --fun=dog cat --port=8080 mouse --hamster --no-bird",
+};
+const makeFlags = (commandLine) => {
+    return (0, flags_js_1.parse)(commandLine.split(" "));
+};
+(0, index_js_1.describe)("Flags", () => {
+    (0, index_js_1.it)("stores the program name", () => {
+        const flags = makeFlags(TEST_CASES.SIMPLE);
+        (0, index_js_1.expect)(flags.argv0).toEqual("program");
+        (0, index_js_1.expect)(flags.args).toEqual([]);
+    });
+    (0, index_js_1.it)("stores the program name ignoring node", () => {
+        const flags = makeFlags(TEST_CASES.NODE);
+        (0, index_js_1.expect)(flags.argv0).toEqual("program");
+        (0, index_js_1.expect)(flags.args).toEqual([]);
+    });
+    (0, index_js_1.it)("parses a flag", () => {
+        const flags = makeFlags(TEST_CASES.ONE_FLAG);
+        (0, index_js_1.expect)(flags.get("fun")).toBe(true);
+    });
+    (0, index_js_1.it)("parses a flag with a default value", () => {
+        const flags = makeFlags(TEST_CASES.SIMPLE);
+        (0, index_js_1.expect)(flags.get("missing")).toBe(false);
+        (0, index_js_1.expect)(flags.get("missing", true)).toBe(true);
+    });
+});

package/lib/cjs/fs.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reset = exports.LocalStorageFileSystemAdapter = exports.ObjectFileSystemAdapter = exports.FileSystem = void 0;
+function join(...paths) {
+    const pathParts = [];
+    for (const path of paths) {
+        for (const part of path.split("/")) {
+            switch (part) {
+                case "":
+                case ".":
+                    break;
+                case "..":
+                    pathParts.pop();
+                    break;
+                default:
+                    pathParts.push(part);
+            }
+        }
+    }
+    return "/" + pathParts.join("/");
+}
+class FileSystem {
+    adapter;
+    wd = "/";
+    stack = [];
+    constructor(adapter = new ObjectFileSystemAdapter()) {
+        this.adapter = adapter;
+    }
+    cwd() {
+        return this.wd;
+    }
+    cd(dir) {
+        this.wd = this.p(dir);
+    }
+    pushd(dir) {
+        this.stack.push(this.wd);
+        this.cd(dir);
+    }
+    popd() {
+        if (this.stack.length > 0) {
+            this.wd = this.stack.pop();
+        }
+    }
+    stat(path) {
+        return this.adapter.stat(join(this.cwd(), path));
+    }
+    readdir(path) {
+        return this.adapter.readdir(this.p(path) + "/");
+    }
+    copyFile(from, to) {
+        return this.adapter.copyFile(this.p(from), this.p(to));
+    }
+    readFile(path) {
+        return this.adapter.readFile(this.p(path));
+    }
+    writeFile(path, contents) {
+        return this.adapter.writeFile(this.p(path), contents);
+    }
+    rm(path) {
+        return this.adapter.rm(this.p(path));
+    }
+    p(path) {
+        return path[0] === "/" ? path : join(this.cwd(), path);
+    }
+}
+exports.FileSystem = FileSystem;
+class ObjectFileSystemAdapter {
+    fs;
+    constructor(fs = {}) {
+        this.fs = fs;
+    }
+    stat(path) {
+        return new Promise((resolve, reject) => {
+            if (this.fs[path] != null) {
+                resolve({
+                    isDirectory() {
+                        return false;
+                    },
+                    isFile() {
+                        return true;
+                    },
+                });
+            }
+            else {
+                reject();
+            }
+        });
+    }
+    readdir(path) {
+        return new Promise((resolve) => {
+            let dir = [];
+            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);
+                    dir.push(basename);
+                }
+            }
+            return resolve(dir);
+        });
+    }
+    copyFile(from, to) {
+        return new Promise((resolve) => {
+            this.fs[to] = this.fs[from];
+            resolve();
+        });
+    }
+    readFile(path) {
+        return new Promise((resolve, reject) => {
+            let file = this.fs[path];
+            if (file === undefined) {
+                reject(new Error(`File Not Found ${path}`));
+            }
+            else {
+                resolve(file);
+            }
+        });
+    }
+    writeFile(path, contents) {
+        return new Promise((resolve) => {
+            this.fs[path] = contents;
+            resolve();
+        });
+    }
+    rm(path) {
+        return new Promise((resolve) => {
+            delete this.fs[path];
+            resolve();
+        });
+    }
+}
+exports.ObjectFileSystemAdapter = ObjectFileSystemAdapter;
+class LocalStorageFileSystemAdapter extends ObjectFileSystemAdapter {
+    constructor() {
+        super(window.localStorage);
+    }
+}
+exports.LocalStorageFileSystemAdapter = LocalStorageFileSystemAdapter;
+async function reset(fs, tree) {
+    for (const [path, file] of Object.entries(tree)) {
+        if (typeof file === "string") {
+            await fs.writeFile(path, file);
+        }
+        else {
+            fs.cd(path);
+            await reset(fs, file);
+            fs.cd("..");
+        }
+    }
+}
+exports.reset = reset;

package/lib/cjs/fs.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_js_1 = require("./fs.js");
+const index_js_1 = require("./scope/index.js");
+(0, index_js_1.describe)("FileSystem", () => {
+    (0, index_js_1.describe)("Writing", () => {
+        (0, index_js_1.it)("Writes files", async () => {
+            const fsObj = {};
+            const fs = new fs_js_1.FileSystem(new fs_js_1.ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("hello", "world");
+            (0, index_js_1.expect)(fsObj).toEqual({ "/hello": "world" });
+        });
+        (0, index_js_1.it)("Writes deep files", async () => {
+            const fsObj = {};
+            const fs = new fs_js_1.FileSystem(new fs_js_1.ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("deep/hello", "world");
+            (0, index_js_1.expect)(fsObj).toEqual({ "/deep/hello": "world" });
+        });
+        (0, index_js_1.it)("Writes deep files from root", async () => {
+            const fsObj = {};
+            const fs = new fs_js_1.FileSystem(new fs_js_1.ObjectFileSystemAdapter(fsObj));
+            await fs.writeFile("/root/deep/hello", "world");
+            (0, index_js_1.expect)(fsObj).toEqual({ "/root/deep/hello": "world" });
+        });
+        (0, index_js_1.it)("Writes files after cd", async () => {
+            const fsObj = {};
+            const fs = new fs_js_1.FileSystem(new fs_js_1.ObjectFileSystemAdapter(fsObj));
+            await fs.cd("deep");
+            await fs.writeFile("hello", "world");
+            (0, index_js_1.expect)(fsObj).toEqual({ "/deep/hello": "world" });
+        });
+    });
+    (0, index_js_1.describe)("directory", () => {
+        (0, index_js_1.it)("returns directory listing", async () => {
+            const fsObj = {
+                "/deep/hello": "world",
+                "/deep/bonjour": "monde",
+                "/other/file": "text",
+            };
+            const fs = new fs_js_1.FileSystem(new fs_js_1.ObjectFileSystemAdapter(fsObj));
+            const dir = await fs.readdir("deep");
+            (0, index_js_1.expect)(dir.sort()).toEqual(["bonjour", "hello"]);
+        });
+    });
+});

package/lib/cjs/generator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeWhile = void 0;
+function* takeWhile(predicate, iterator) {
+    for (const x of iterator) {
+        if (predicate(x)) {
+            yield x;
+        }
+        else {
+            return;
+        }
+    }
+}
+exports.takeWhile = takeWhile;

package/lib/cjs/generator.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_js_1 = require("./generator.js");
+const index_js_1 = require("./scope/index.js");
+(0, index_js_1.describe)("Generator", () => {
+    (0, index_js_1.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 = [...(0, generator_js_1.takeWhile)(filter(), generator())];
+        (0, index_js_1.expect)(values).toEqual([2, 4, 8, 16, 32, 64, 128]);
+    });
+});

package/lib/cjs/is_browser.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsBrowser = void 0;
+exports.IsBrowser = typeof window !== "undefined";

package/lib/cjs/loader.mjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = exports.resolve = void 0;
+const promises_1 = require("node:fs/promises");
+const node_process_1 = require("node:process");
+const node_url_1 = require("node:url");
+const transpile_mjs_1 = require("./transpile.mjs");
+const baseURL = (0, node_url_1.pathToFileURL)(`${(0, node_process_1.cwd)()}/`).href;
+/** @returns {Promise<{url: string}>} */
+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 (0, promises_1.stat)((0, node_url_1.fileURLToPath)(tsURL));
+        if (stats.isFile()) {
+            return { url: tsSpecifier };
+        }
+    }
+    catch (e) {
+        // Do nothing
+    }
+    return defaultResolve(specifier, context, defaultResolve);
+}
+exports.resolve = resolve;
+/** @returns {Promise<{format: string, source: string}>} */
+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 (0, transpile_mjs_1.transpile)(url, async () => (await defaultLoad(url, { format: "module" })).source),
+        }
+        : defaultLoad(url, context, defaultLoad);
+}
+exports.load = load;

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/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/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>[];