@davidsouther/jiffies 1.0.0 → 1.1.0

package/build/fs.js

@@ -1,144 +1,144 @@
-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("/");
-}
-export 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);
-    }
-}
-export 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();
-            }
-            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 ObjectFileSystemAdapter {
-    constructor() {
-        super(window.localStorage);
-    }
-}
-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("..");
-        }
-    }
-}
+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("/");
+}
+export 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);
+    }
+}
+export 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();
+            }
+            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 ObjectFileSystemAdapter {
+    constructor() {
+        super(window.localStorage);
+    }
+}
+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/build/fs.test.d.ts

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

package/build/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/build/generator.d.ts

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

package/build/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/build/generator.test.d.ts

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

package/build/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/build/is_browser.d.ts

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

package/build/is_browser.js

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

package/build/loader.d.mts

@@ -1,22 +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;
-}>;
+/** @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/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/build/lock.d.ts

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

package/build/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/build/lock.test.d.ts

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