@davidsouther/jiffies 1.0.0 → 1.1.0

package/build/dom/types/html.js

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

package/build/dom/xml.d.ts

@@ -1 +1 @@
-export declare function xml(tag: string, attributes: Record<string, string | number | boolean>, children?: string[]): string;
+export declare function xml(tag: string, attributes: Record<string, string | number | boolean>, children?: string[]): string;

package/build/dom/xml.js

@@ -1,5 +1,4 @@
-export function xml(tag, attributes, children = []) {
-    const attrs = Object.entries(attributes).reduce((attrs, [attr, val]) => `${attrs} ${attr}="${val}"`, "");
-    const kids = children.join("");
-    return `<${tag} ${attrs}>${kids}</${tag}>`;
-}
+export function xml(tag, attributes, children = []) {
+    const attrs = Object.entries(attributes).reduce((attrs, [attr, val]) => `${attrs} ${attr}="${val}"`, "");
+    return `<${tag} ${attrs}>${children.join("")}</${tag}>`;
+}

package/build/equal.d.ts

@@ -1,5 +1,5 @@
-export declare function compareArrays<T>(equal: (a: T, b: T, partial: boolean) => boolean): (A: T[], B: T[], partial?: boolean) => boolean;
-export declare const equalArrays: (A: any[], B: any[], partial?: boolean) => boolean;
-export declare const matchArrays: <A>(a: A[], b: A[], partial?: boolean) => boolean;
-export declare const matchObjects: (a: {}, b: {}, partial?: boolean) => boolean;
-export declare function equals<A>(a: A | A[], b: A | A[], partial?: boolean): boolean;
+export declare function compareArrays<T>(equal: (a: T, b: T, partial: boolean) => boolean): (A: T[], B: T[], partial?: boolean) => boolean;
+export declare const equalArrays: (A: any[], B: any[], partial?: boolean) => boolean;
+export declare const matchArrays: <A>(a: A[], b: A[], partial?: boolean) => boolean;
+export declare const matchObjects: (a: {}, b: {}, partial?: boolean) => boolean;
+export declare function equals<A>(a: A | A[], b: A | A[], partial?: boolean): boolean;

package/build/equal.js

@@ -1,37 +1,37 @@
-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);
-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
-    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);
-    }
-}
+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);
+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
+    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/build/equal.test.d.ts

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

package/build/equal.test.js

@@ -1,20 +1,20 @@
-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);
-    });
-});
+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/build/flags.d.ts

@@ -1,7 +1,7 @@
-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;
-};
+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/build/flags.js

@@ -1,48 +1,48 @@
-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;
-        },
-    };
-};
+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/build/flags.test.d.ts

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

package/build/flags.test.js

@@ -1,35 +1,35 @@
-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);
-    });
-});
+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/build/fs.d.ts

@@ -1,48 +1,48 @@
-export declare type PathLike = string;
-export interface Stats {
-    isDirectory(): boolean;
-    isFile(): boolean;
-}
-interface FileSystemAdapter {
-    stat(path: PathLike): Promise<Stats>;
-    readdir(path: PathLike): Promise<string[]>;
-    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: ObjectFileSystemAdapter;
-    protected wd: string;
-    protected stack: string[];
-    constructor(adapter?: ObjectFileSystemAdapter);
-    cwd(): string;
-    cd(dir: string): void;
-    pushd(dir: string): void;
-    popd(): void;
-    stat(path: PathLike): Promise<Stats>;
-    readdir(path: PathLike): Promise<string[]>;
-    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 ObjectFileSystemAdapter implements FileSystemAdapter {
-    private fs;
-    constructor(fs?: Record<string, string>);
-    stat(path: PathLike): Promise<Stats>;
-    readdir(path: PathLike): Promise<string[]>;
-    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 ObjectFileSystemAdapter {
-    constructor();
-}
-export interface Tree {
-    [k: string]: string | Tree;
-}
-export declare function reset(fs: FileSystem, tree: Tree): Promise<void>;
-export {};
+export declare type PathLike = string;
+export interface Stats {
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+interface FileSystemAdapter {
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    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: ObjectFileSystemAdapter;
+    protected wd: string;
+    protected stack: string[];
+    constructor(adapter?: ObjectFileSystemAdapter);
+    cwd(): string;
+    cd(dir: string): void;
+    pushd(dir: string): void;
+    popd(): void;
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    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 ObjectFileSystemAdapter implements FileSystemAdapter {
+    private fs;
+    constructor(fs?: Record<string, string>);
+    stat(path: PathLike): Promise<Stats>;
+    readdir(path: PathLike): Promise<string[]>;
+    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 ObjectFileSystemAdapter {
+    constructor();
+}
+export interface Tree {
+    [k: string]: string | Tree;
+}
+export declare function reset(fs: FileSystem, tree: Tree): Promise<void>;
+export {};