@davidsouther/jiffies 2.2.5 → 2026.4.0

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.d.ts

@@ -1,7 +0,0 @@
-export declare const parse: (parseArgs: string[]) => {
-    readonly argv0: string;
-    readonly args: readonly string[];
-    get(flag: string, def?: boolean): boolean;
-    asNumber(param: string, def?: number): number;
-    asString(param: string, def?: string): string;
-};

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.d.ts

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

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.d.ts

@@ -1,72 +0,0 @@
-export declare type PathLike = string;
-export interface PlatformParts {
-    SEP: string;
-    WD: string;
-    isAbsolute(path: PathLike): boolean;
-}
-export declare const PLATFORM_PARTS_WIN: PlatformParts;
-export declare const PLATFORM_PARTS_UNIX: PlatformParts;
-export declare const PLATFORM_PARTS: PlatformParts;
-export declare const SEP: string;
-export declare const WD: string;
-export declare const isAbsolute: (path: PathLike) => boolean;
-export interface Stats {
-    isDirectory(): boolean;
-    isFile(): boolean;
-    name: string;
-}
-export declare function basename(filename: PathLike): string;
-export interface FileSystemAdapter {
-    stat(path: PathLike): Promise<Stats>;
-    readdir(path: PathLike): Promise<string[]>;
-    scandir(path: PathLike): Promise<Stats[]>;
-    mkdir(path: PathLike): Promise<void>;
-    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: FileSystemAdapter;
-    protected wd: string;
-    protected stack: string[];
-    constructor(adapter?: FileSystemAdapter);
-    cwd(): string;
-    cd(dir: string): void;
-    pushd(dir: string): void;
-    popd(): void;
-    stat(path: PathLike): Promise<Stats>;
-    scandir(path: PathLike): Promise<Stats[]>;
-    readdir(path: PathLike): Promise<string[]>;
-    mkdir(path: string): Promise<void>;
-    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 RecordFileSystemAdapter implements FileSystemAdapter {
-    private fs;
-    constructor(fs?: Record<string, string>);
-    stat(path: PathLike): Promise<Stats>;
-    scandir(path: PathLike): Promise<Stats[]>;
-    readdir(path: PathLike): Promise<string[]>;
-    mkdir(path: string): Promise<void>;
-    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 RecordFileSystemAdapter {
-    constructor();
-}
-export declare type ObjectFileSystem = {
-    [k: string]: string | ObjectFileSystem;
-};
-export declare class ObjectFileSystemAdapter extends RecordFileSystemAdapter {
-    constructor(object: ObjectFileSystem);
-}
-export interface Tree {
-    [k: string]: string | Tree;
-}
-export declare function reset(fs: FileSystem, tree: Tree): Promise<void>;

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.d.ts

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

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.d.ts

@@ -1,15 +0,0 @@
-import { FileSystem, FileSystemAdapter, Stats } from "./fs.js";
-export declare class NodeFileSystem extends FileSystem {
-    constructor(cd?: string);
-}
-/** Jiffies FileSystemAdapter using NodeJS' fs/promises. */
-export declare class NodeFileSystemAdapter implements FileSystemAdapter {
-    stat(path: string): Promise<Stats>;
-    readdir(path: string): Promise<string[]>;
-    mkdir(path: string): Promise<void>;
-    scandir(path: string): Promise<Stats[]>;
-    copyFile(from: string, to: string): Promise<void>;
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, contents: string): Promise<void>;
-    rm(path: string): Promise<void>;
-}

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.d.ts

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

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.d.ts

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

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.d.ts

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

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.d.ts

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

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;
-}>;