@davidsouther/jiffies 2.2.5 → 2.3.0

package/lib/esm/equal.js

@@ -1,41 +0,0 @@
-export function compareArrays(equal) {
-    return (a, b, partial = false) => a.length === b.length && a.every((e, i) => equal(e, b[i], partial));
-}
-export const equalArrays = compareArrays(Object.is);
-export const matchArrays = compareArrays(equals);
-export function asArray(a) {
-    return Object.entries(a).sort((a, b) => a[0].localeCompare(b[0]));
-}
-export 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;
-};
-export function equals(a, b, partial = false) {
-    // runtime type checking
-    if (a === null && a === b)
-        return true;
-    if (a === undefined && a === b)
-        return true;
-    switch (typeof a) {
-        case "object":
-            if (b === undefined) {
-                return false;
-            }
-            if (a instanceof Array && b instanceof Array) {
-                return matchArrays(a, b, partial);
-            }
-            else {
-                return matchObjects(a, b, partial);
-            }
-        case "function":
-            return a.name === b.name;
-        default:
-            return Object.is(a, b);
-    }
-}

package/lib/esm/equal.test.js

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "./scope/index.js";
-import { equalArrays, equals, matchArrays } from "./equal.js";
-describe("Equality", () => {
-    it("compares objects", () => {
-        expect(equals({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true);
-        expect(equals({ a: 1, b: 2 }, { b: 1, a: 2 })).toBe(false);
-    });
-    it("compares primitives", () => {
-        expect(equals(1, 1)).toBe(true);
-        expect(equals(1, -1)).toBe(false);
-        expect(equals(0, -0)).toBe(false);
-        expect(equals(NaN, NaN)).toBe(true);
-    });
-    it("compares arrays", () => {
-        expect(equalArrays([1, 2, 3], [1, 2, 3])).toBe(true);
-        expect(equalArrays([1], [2, 3])).toBe(false);
-        expect(equalArrays([{ a: 1 }], [{ a: 1 }])).toBe(false);
-        expect(matchArrays([{ a: 1 }], [{ a: 1 }])).toBe(true);
-    });
-});

package/lib/esm/flags.js

@@ -1,48 +0,0 @@
-export 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;
-        },
-    };
-};

package/lib/esm/flags.test.js

@@ -1,35 +0,0 @@
-import { describe, it, expect } from "./scope/index.js";
-import { parse } from "./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 parse(commandLine.split(" "));
-};
-describe("Flags", () => {
-    it("stores the program name", () => {
-        const flags = makeFlags(TEST_CASES.SIMPLE);
-        expect(flags.argv0).toEqual("program");
-        expect(flags.args).toEqual([]);
-    });
-    it("stores the program name ignoring node", () => {
-        const flags = makeFlags(TEST_CASES.NODE);
-        expect(flags.argv0).toEqual("program");
-        expect(flags.args).toEqual([]);
-    });
-    it("parses a flag", () => {
-        const flags = makeFlags(TEST_CASES.ONE_FLAG);
-        expect(flags.get("fun")).toBe(true);
-    });
-    it("parses a flag with a default value", () => {
-        const flags = makeFlags(TEST_CASES.SIMPLE);
-        expect(flags.get("missing")).toBe(false);
-        expect(flags.get("missing", true)).toBe(true);
-    });
-});

package/lib/esm/fs.js

@@ -1,226 +0,0 @@
-export const PLATFORM_PARTS_WIN = {
-    SEP: "\\",
-    WD: "C:\\\\",
-    isAbsolute: (path) => Boolean(path.match(new RegExp("^[a-zA-Z]:\\\\"))),
-};
-export const PLATFORM_PARTS_UNIX = {
-    SEP: "/",
-    WD: "/",
-    isAbsolute: (path) => path[0] == "/",
-};
-export const PLATFORM_PARTS = typeof process !== "undefined" && process.platform == "win32"
-    ? PLATFORM_PARTS_WIN
-    : PLATFORM_PARTS_UNIX;
-export const SEP = PLATFORM_PARTS.SEP;
-export const WD = PLATFORM_PARTS.WD;
-export const isAbsolute = PLATFORM_PARTS.isAbsolute;
-export function basename(filename) {
-    if (filename.endsWith(SEP)) {
-        filename = filename.substring(0, filename.length - 1);
-    }
-    const basename = filename.split(SEP).at(-1) ?? "";
-    return basename;
-}
-function join(...paths) {
-    const pathParts = [];
-    for (const path of paths) {
-        for (const part of path.split(SEP)) {
-            switch (part) {
-                case "":
-                case ".":
-                    break;
-                case "..":
-                    pathParts.pop();
-                    break;
-                default:
-                    pathParts.push(part);
-            }
-        }
-    }
-    return ((PLATFORM_PARTS == PLATFORM_PARTS_UNIX ? SEP : "") + pathParts.join(SEP));
-}
-export class FileSystem {
-    adapter;
-    wd = WD;
-    stack = [];
-    constructor(adapter = new RecordFileSystemAdapter()) {
-        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(this.p(path));
-    }
-    scandir(path) {
-        return this.adapter.scandir(this.p(path));
-    }
-    readdir(path) {
-        return this.adapter.readdir(this.p(path));
-    }
-    mkdir(path) {
-        return this.adapter.mkdir(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 isAbsolute(path) ? path : join(this.cwd(), path);
-    }
-}
-export class RecordFileSystemAdapter {
-    fs;
-    constructor(fs = {}) {
-        this.fs = fs;
-    }
-    stat(path) {
-        return new Promise((resolve, reject) => {
-            if (this.fs[path]) {
-                return resolve({
-                    name: basename(path),
-                    isDirectory() {
-                        return false;
-                    },
-                    isFile() {
-                        return true;
-                    },
-                });
-            }
-            if (!path.endsWith(SEP))
-                path += SEP;
-            for (let filename of Object.keys(this.fs)) {
-                if (filename.startsWith(path)) {
-                    return resolve({
-                        name: basename(path),
-                        isDirectory() {
-                            return true;
-                        },
-                        isFile() {
-                            return false;
-                        },
-                    });
-                }
-            }
-            reject();
-        });
-    }
-    async scandir(path) {
-        return (await this.readdir(path)).map((name) => {
-            let isFile = this.fs[join(path, name)] !== undefined;
-            return {
-                name,
-                isDirectory() {
-                    return !isFile;
-                },
-                isFile() {
-                    return isFile;
-                },
-            };
-        });
-    }
-    readdir(path) {
-        if (!path.endsWith(SEP))
-            path += SEP;
-        return new Promise((resolve) => {
-            let dir = new Set();
-            for (const filename of Object.keys(this.fs)) {
-                if (filename.startsWith(path)) {
-                    const end = filename.indexOf(SEP, path.length + 1);
-                    const basename = filename.substring(path.length, end === -1 ? undefined : end);
-                    dir.add(basename);
-                }
-            }
-            return resolve([...dir].sort());
-        });
-    }
-    mkdir(path) {
-        return Promise.resolve();
-    }
-    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) {
-                const error = new Error(`File Not Found ${path}`);
-                reject(error);
-            }
-            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();
-        });
-    }
-}
-export class LocalStorageFileSystemAdapter extends RecordFileSystemAdapter {
-    constructor() {
-        super(window.localStorage);
-    }
-}
-export class ObjectFileSystemAdapter extends RecordFileSystemAdapter {
-    constructor(object) {
-        super(reduceObjectFileSystem(object));
-    }
-}
-function reduceObjectFileSystem(object) {
-    let level = {};
-    for (let [k, v] of Object.entries(object)) {
-        if (typeof v == "string") {
-            level[`/${k}`] = v;
-        }
-        else {
-            for (let [k2, v2] of Object.entries(reduceObjectFileSystem(v))) {
-                level[`/${k}${k2}`] = v2;
-            }
-        }
-    }
-    return level;
-}
-export 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("..");
-        }
-    }
-}

package/lib/esm/fs.test.js

@@ -1,84 +0,0 @@
-import { FileSystem, ObjectFileSystemAdapter, RecordFileSystemAdapter, } from "./fs.js";
-import { describe, it, expect, beforeEach } from "./scope/index.js";
-import { cleanState } from "./scope/state.js";
-describe("FileSystem", () => {
-    describe("Writing", () => {
-        it("Writes files", async () => {
-            const fsObj = {};
-            const fs = new FileSystem(new RecordFileSystemAdapter(fsObj));
-            await fs.writeFile("hello", "world");
-            expect(fsObj).toEqual({ "/hello": "world" });
-        });
-        it("Writes deep files", async () => {
-            const fsObj = {};
-            const fs = new FileSystem(new RecordFileSystemAdapter(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 RecordFileSystemAdapter(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 RecordFileSystemAdapter(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 RecordFileSystemAdapter(fsObj));
-            const dir = await fs.readdir("deep");
-            expect(dir.sort()).toEqual(["bonjour", "hello"]);
-        });
-    });
-    describe("stat", () => {
-        const state = cleanState(() => {
-            const fsObj = {
-                "/deep/hello": "world",
-                "/deep/bonjour": "monde",
-                "/other/file": "text",
-            };
-            return { fs: new FileSystem(new RecordFileSystemAdapter(fsObj)) };
-        }, beforeEach);
-        it("stats a directory", async () => {
-            const deep = await state.fs.stat("/deep");
-            expect(deep.isDirectory()).toBe(true);
-            expect(deep.isFile()).toBe(false);
-        });
-        it("stats a file", async () => {
-            const deep = await state.fs.stat("/deep/hello");
-            expect(deep.isDirectory()).toBe(false);
-            expect(deep.isFile()).toBe(true);
-        });
-    });
-    describe("ObjectFileSystem", () => {
-        it("treats object keys as directories and final values as strings", async () => {
-            const fsAdapter = new ObjectFileSystemAdapter({
-                deep: {
-                    hello: "world",
-                    bonjour: "monde",
-                },
-                other_file: "text",
-            });
-            expect([
-                ...Object.keys(fsAdapter.fs),
-            ]).toEqual(["/deep/hello", "/deep/bonjour", "/other_file"]);
-            let fs = new FileSystem(fsAdapter);
-            const deep = await fs.stat("/deep");
-            expect(deep.isDirectory()).toBe(true);
-            expect(deep.isFile()).toBe(false);
-            const deep_bonjour = await fs.readFile("/deep/bonjour");
-            expect(deep_bonjour).toBe("monde");
-        });
-    });
-});

package/lib/esm/fs_node.js

@@ -1,45 +0,0 @@
-import { FileSystem } from "./fs.js";
-import { copyFile, mkdir, readdir, readFile, rm, stat, writeFile, } from "fs/promises";
-import { basename, join } from "path";
-export class NodeFileSystem extends FileSystem {
-    constructor(cd = process.cwd()) {
-        super(new NodeFileSystemAdapter());
-        this.cd(cd);
-    }
-}
-/** Jiffies FileSystemAdapter using NodeJS' fs/promises. */
-export class NodeFileSystemAdapter {
-    async stat(path) {
-        const fsStat = await stat(path);
-        return {
-            name: basename(path),
-            isDirectory() {
-                return fsStat.isDirectory();
-            },
-            isFile() {
-                return !fsStat.isDirectory();
-            },
-        };
-    }
-    readdir(path) {
-        return readdir(path);
-    }
-    mkdir(path) {
-        return mkdir(path);
-    }
-    async scandir(path) {
-        return Promise.all((await this.readdir(path)).map((name) => this.stat(join(path, name))));
-    }
-    copyFile(from, to) {
-        return copyFile(from, to);
-    }
-    readFile(path) {
-        return readFile(path, "utf-8");
-    }
-    writeFile(path, contents) {
-        return writeFile(path, contents, "utf-8");
-    }
-    rm(path) {
-        return rm(path, { force: true, recursive: true });
-    }
-}

package/lib/esm/fs_win.test.js

@@ -1,8 +0,0 @@
-import { NodeFileSystem } from "./fs_node.js";
-const fs = new NodeFileSystem();
-async function main() {
-    for (const stats of await fs.scandir(".")) {
-        console.log(stats);
-    }
-}
-main();

package/lib/esm/generator.js

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

package/lib/esm/generator.test.js

@@ -1,24 +0,0 @@
-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.js

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

package/lib/esm/loader-register.d.mts

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

package/lib/esm/loader-register.mjs

@@ -1,2 +0,0 @@
-import { register } from 'node:module';
-register('./loader.mjs', import.meta.url);

package/lib/esm/loader.d.mts

@@ -1,23 +0,0 @@
-/** @returns {Promise<{url: string, shortCircuit?: boolean}>} */
-export function resolve(specifier: string, context: {
-    parentURL?: string;
-}, defaultResolve: (specifier: string, context: {
-    parentURL?: string;
-}, defaultResolve: Function) => Promise<{
-    url: string;
-}>): Promise<{
-    url: string;
-    shortCircuit?: boolean;
-}>;
-/** @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/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.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.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);
-    });
-});