@davidsouther/jiffies 2.2.4 → 2.3.0

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

package/lib/esm/log.js

@@ -1,88 +0,0 @@
-import { display } from "./display.js";
-export const LEVEL = {
-    UNKNOWN: 2,
-    DEBUG: 1,
-    VERBOSE: 1,
-    INFO: 2,
-    WARN: 3,
-    ERROR: 4,
-    SILENT: 5,
-};
-export const LEVELS = {
-    unknown: LEVEL.UNKNOWN,
-    debug: LEVEL.DEBUG,
-    verbose: LEVEL.VERBOSE,
-    info: LEVEL.INFO,
-    warn: LEVEL.WARN,
-    error: LEVEL.ERROR,
-    silent: LEVEL.SILENT,
-};
-export function getLogLevel(level = "") {
-    return (LEVELS[level.toLowerCase()] ?? (!isNaN(+level) ? Number(level) : LEVEL.INFO));
-}
-export function basicLogFormatter(data) {
-    return `${data.prefix}: ${data.message}`;
-}
-function findSource() {
-    const err = new Error();
-    // Stack will be:
-    // findSource
-    // logAt
-    // {source}
-    const lines = err.stack?.split("\n") ?? [];
-    const atLines = lines.filter((line) => line.match(/^\s*at/));
-    return atLines[2]?.trim().slice("at ".length) ?? "(unknown)";
-}
-export function getLogger(name, args = {
-    format: JSON.stringify,
-    console,
-}) {
-    if (args instanceof Function) {
-        args = { format: args };
-    }
-    const logAt = (level, prefix, fn) => (message, data) => level >= (logger.level ?? LEVEL.SILENT)
-        ? fn(logger.format({
-            name,
-            prefix,
-            level,
-            message: display(message),
-            ...data,
-            source: findSource(),
-        }))
-        : undefined;
-    const logger = {
-        level: LEVEL.INFO,
-        format: args.format ?? JSON.stringify,
-        console: args.console ?? global.console,
-        debug: logAt(LEVEL.DEBUG, "DEBUG", (l) => logger.console.debug(l)),
-        info: logAt(LEVEL.INFO, "INFO", (l) => logger.console.info(l)),
-        warn: logAt(LEVEL.WARN, "WARN", (l) => logger.console.warn(l)),
-        error: logAt(LEVEL.ERROR, "ERR", (l) => logger.console.error(l)),
-    };
-    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.js

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