@davidsouther/jiffies 1.0.0-beta.1

package/build/flags.d.ts

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

package/build/flags.js

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

package/build/flags.test.d.ts

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

package/build/flags.test.js

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

package/build/generator.d.ts

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

package/build/generator.js

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

package/build/generator.test.d.ts

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

package/build/generator.test.js

@@ -0,0 +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]);
+    });
+});

package/build/index.d.ts

@@ -0,0 +1,13 @@
+export * as assert from "./assert";
+export * as case from "./case";
+export * as context from "./context";
+export * as debounce from "./debounce";
+export * as display from "./display";
+export * as equal from "./equal";
+export * as generator from "./generator";
+export * as lock from "./lock";
+export * as range from "./range";
+export * as result from "./result";
+export * as safe from "./safe";
+export * as components from "./components";
+export * as dom from "./dom/dom";

package/build/index.js

@@ -0,0 +1,13 @@
+export * as assert from "./assert";
+export * as case from "./case";
+export * as context from "./context";
+export * as debounce from "./debounce";
+export * as display from "./display";
+export * as equal from "./equal";
+export * as generator from "./generator";
+export * as lock from "./lock";
+export * as range from "./range";
+export * as result from "./result";
+export * as safe from "./safe";
+export * as components from "./components";
+export * as dom from "./dom/dom";

package/build/is_browser.d.ts

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

package/build/is_browser.js

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

package/build/loader.d.mts

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

package/build/loader.mjs

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

package/build/lock.d.ts

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

package/build/lock.js

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

package/build/lock.test.d.ts

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

package/build/lock.test.js

@@ -0,0 +1,16 @@
+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/build/log.d.ts

@@ -0,0 +1,26 @@
+import { Display } from "./display.js";
+export interface Log {
+    (message: Display, data?: {}): void;
+}
+export interface Logger {
+    level: Number;
+    debug: Log;
+    info: Log;
+    warn: Log;
+    error: Log;
+}
+export declare const LEVEL: {
+    UNKNOWN: number;
+    SILENT: number;
+    DEBUG: number;
+    VERBOSE: number;
+    INFO: number;
+    WARN: number;
+    ERROR: number;
+};
+export declare function getLogger(name: string): Logger;
+export declare const DEFAULT_LOGGER: Logger;
+export declare function debug(message: Display, data?: {}): void;
+export declare function info(message: Display, data?: {}): void;
+export declare function warn(message: Display, data?: {}): void;
+export declare function error(message: Display, data?: {}): void;

package/build/log.js

@@ -0,0 +1,34 @@
+import { display } from "./display.js";
+export const LEVEL = {
+    UNKNOWN: 0,
+    SILENT: 0,
+    DEBUG: 1,
+    VERBOSE: 1,
+    INFO: 2,
+    WARN: 3,
+    ERROR: 4,
+};
+export function getLogger(name) {
+    const logger = { level: LEVEL.INFO };
+    const logAt = (level, fn) => (message, data) => level >= (logger.level ?? LEVEL.SILENT)
+        ? fn(display(message), data)
+        : undefined;
+    logger.debug = logAt(LEVEL.VERBOSE, console.debug.bind(console));
+    logger.info = logAt(LEVEL.INFO, console.info.bind(console));
+    logger.warn = logAt(LEVEL.WARN, console.warn.bind(console));
+    logger.error = logAt(LEVEL.ERROR, console.error.bind(console));
+    return logger;
+}
+export const DEFAULT_LOGGER = getLogger("default");
+export function debug(message, data) {
+    DEFAULT_LOGGER.debug(message, data);
+}
+export function info(message, data) {
+    DEFAULT_LOGGER.info(message, data);
+}
+export function warn(message, data) {
+    DEFAULT_LOGGER.warn(message, data);
+}
+export function error(message, data) {
+    DEFAULT_LOGGER.error(message, data);
+}

package/build/parcel_resolver.d.ts

@@ -0,0 +1,3 @@
+declare const _default: Resolver;
+export default _default;
+import { Resolver } from "@parcel/plugin";

package/build/parcel_resolver.js

@@ -0,0 +1,19 @@
+import { Resolver } from "@parcel/plugin";
+export default new Resolver({
+    async resolve({ specifier }) {
+        console.log(specifier);
+        // const tsURL = new URL(
+        //     specifier.replace(/js$/, "ts"),
+        // );
+        // const tsSpecifier = tsURL.href;
+        // try {
+        //     const stats = await stat(fileURLToPath(tsURL));
+        //     if (stats.isFile()) {
+        //     return { url: tsSpecifier };
+        //     }
+        // } catch (e) {
+        //     // Do nothing
+        // }
+        return null;
+    },
+});

package/build/range.d.ts

@@ -0,0 +1 @@
+export declare function range(start: number, end: number, stride?: number): number[];

package/build/range.js

@@ -0,0 +1,7 @@
+export function range(start, end, stride = 1) {
+    const range = [];
+    for (let i = start; i < end; i += stride) {
+        range.push(i);
+    }
+    return range;
+}

package/build/result.d.ts

@@ -0,0 +1,31 @@
+export declare type None = null;
+export declare type Some<T> = T;
+export declare type Option<T> = Some<T> | None;
+export declare type Err<E extends Error> = {
+    err: E;
+    map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
+};
+export declare type Ok<T> = {
+    ok: T;
+    map: <U>(fn: (t: T) => Result<U>) => Result<U>;
+};
+export declare type Result<T, E extends Error = Error> = Ok<T> | Err<E>;
+export declare const isNone: <T>(s: Option<T>) => s is null;
+export declare const isSome: <T>(s: Option<T>) => s is T;
+export declare function None<T = unknown>(_?: T): Option<T>;
+export declare function Some<T>(t: Option<T>): Option<T>;
+export declare function Some<T>(t: T): Option<T>;
+export declare const isOk: <T, E extends Error>(t: Result<T, E>) => t is Ok<T>;
+export declare const isErr: <T, E extends Error>(e: Result<T, E>) => boolean;
+export declare const isResult: <T, E extends Error>(t: Result<T, E>) => t is Result<T, E>;
+export declare function Ok<T>(ok: Ok<T>): T;
+export declare function Ok<T>(t: T): Ok<T>;
+export declare function Err<E extends Error>(e: Err<E>): E;
+export declare function Err<E extends Error>(e: E): Err<E>;
+export declare function Err<E extends Error>(e: string): Err<E>;
+export declare function unwrap<T, E extends Error>(result: Result<T, E>): T | never;
+export declare function unwrap<O>(some: Option<O>): O | never;
+export declare function unwrapOr<T, E extends Error>(result: Result<T, E>, def: T): T;
+export declare function unwrapOr<T>(some: Some<T>, def: T): T;
+export declare function unwrapOrElse<T, E extends Error>(result: Result<T, Error>, def: () => T): T;
+export declare function unwrapOrElse<T>(some: Some<T>, def: () => T): T;

package/build/result.js

@@ -0,0 +1,65 @@
+export const isNone = (s) => s == null;
+export const isSome = (s) => s != null;
+export function None(_) {
+    return null;
+}
+export function Some(t) {
+    return t;
+}
+export const isOk = (t) => t.ok !== undefined;
+export const isErr = (e) => e.err !== undefined;
+export const isResult = (t) => isOk(t) || isErr(t);
+export function Ok(t) {
+    return t.ok
+        ? t.ok
+        : {
+            ok: t,
+            map(fn) {
+                return fn(Ok(this));
+            },
+        };
+}
+export function Err(e) {
+    return (e.err ?? {
+        err: typeof e === "string" ? new Error(e) : e,
+        map(fn) {
+            return this;
+        },
+    });
+}
+export function unwrap(t) {
+    if (isNone(t)) {
+        throw new Error(`Attempted to unwrap None`);
+    }
+    if (isErr(t)) {
+        throw Err(t);
+    }
+    if (isOk(t)) {
+        return Ok(t);
+    }
+    return t;
+}
+export function unwrapOr(t, def) {
+    if (isNone(t)) {
+        return def;
+    }
+    if (isErr(t)) {
+        return def;
+    }
+    if (isOk(t)) {
+        return Ok(t);
+    }
+    return t;
+}
+export function unwrapOrElse(t, def) {
+    if (isNone(t)) {
+        return def();
+    }
+    if (isErr(t)) {
+        return def();
+    }
+    if (isOk(t)) {
+        return Ok(t);
+    }
+    return t;
+}

package/build/result.test.d.ts

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

package/build/result.test.js

@@ -0,0 +1,71 @@
+import { Err, None, Ok, Some, unwrap, unwrapOr, unwrapOrElse, } from "./result.js";
+import { describe, it } from "./scope/describe.js";
+import { expect } from "./scope/expect.js";
+describe("Result", () => {
+    it("converts Nones", () => {
+        const a = None();
+        expect(a).toBeNull();
+        const b = None();
+        expect(b).toBeNull();
+        const c = Some(a);
+        expect(c).toBeNull();
+        const d = Some(b);
+        expect(d).toBeNull();
+    });
+    it("converts Somes", () => {
+        const a = Some("a");
+        expect(a).toBe("a");
+        const b = Some(a);
+        expect(b).toBe("a");
+    });
+    it("converts Errs", () => {
+        const a = Err(new Error("a error"));
+        const b = Err(a);
+        expect(b).toMatchObject({ message: "a error" });
+        // Assign Err to Result
+        const c = a;
+    });
+    it("converts Oks", () => {
+        const a = Ok("a ok");
+        const b = Ok(a);
+        expect(b).toBe("a ok");
+        // Assign ok to Result
+        const c = a;
+    });
+    it("unwraps", () => {
+        const a = Some("some");
+        const b = None();
+        const c = Ok("ok");
+        const d = Err(new Error("err"));
+        const e = "else";
+        expect(unwrap(a)).toBe("some");
+        expect(unwrap(c)).toBe("ok");
+        expect(() => unwrap(b)).toThrow("Attempted to unwrap None");
+        expect(() => unwrap(d)).toThrow("err");
+        expect(unwrap(e)).toBe("else");
+    });
+    it("unwrapsOrs", () => {
+        const a = Some("some");
+        const b = None();
+        const c = Ok("ok");
+        const d = Err(new Error("err"));
+        const e = "else";
+        expect(unwrapOr(a, "z")).toBe("some");
+        expect(unwrapOr(c, "z")).toBe("ok");
+        expect(unwrapOr(b, "z")).toBe("z");
+        expect(unwrapOr(d, "z")).toBe("z");
+        expect(unwrapOr(e, "z")).toBe("else");
+    });
+    it("unwrapsOrElse", () => {
+        const a = Some("some");
+        const b = None();
+        const c = Ok("ok");
+        const d = Err(new Error("err"));
+        const e = "else";
+        expect(unwrapOrElse(a, () => "z")).toBe("some");
+        expect(unwrapOrElse(c, () => "z")).toBe("ok");
+        expect(unwrapOrElse(b, () => "z")).toBe("z");
+        expect(unwrapOrElse(d, () => "z")).toBe("z");
+        expect(unwrapOrElse(e, () => "z")).toBe("else");
+    });
+});

package/build/safe.d.ts

@@ -0,0 +1 @@
+export declare const safe: <A extends unknown[], R>(fn: (...args: A) => R, r: R) => (...args: A) => R;

package/build/safe.js

@@ -0,0 +1,10 @@
+import { error } from "./log.js";
+export const safe = (fn, r) => (...args) => {
+    try {
+        return fn(...args);
+    }
+    catch (e) {
+        error(`${e}`);
+        return r;
+    }
+};

package/build/scope/describe.d.ts

@@ -0,0 +1,14 @@
+import { TestCase } from "./scope.js";
+export declare const beforeall: unique symbol;
+export declare const beforeeach: unique symbol;
+export declare const afterall: unique symbol;
+export declare const aftereach: unique symbol;
+export declare function rootCases(): TestCase;
+export declare function getTotalCases(): number;
+export declare function describe(title: string, block: Function): void;
+export declare function it(title: string, block: Function): void;
+export declare function beforeEach(fn: () => void): void;
+export declare function beforeAll(fn: () => void): void;
+export declare function afterEach(fn: () => void): void;
+export declare function afterAll(fn: () => void): void;
+export declare function cleanState<State extends {}>(init: () => State, runner?: (action: () => void) => void): State;

package/build/scope/describe.js

@@ -0,0 +1,52 @@
+import { getLogger } from "../log.js";
+export const beforeall = Symbol("beforeAll");
+export const beforeeach = Symbol("beforeEach");
+export const afterall = Symbol("afterAll");
+export const aftereach = Symbol("afterEach");
+const logger = getLogger("scope");
+const CASES = {};
+let cases = [CASES];
+let totalCases = 0;
+function push(title) {
+    const next = (cases[0][title] = {});
+    cases.unshift(next);
+}
+function pop() {
+    cases.shift();
+}
+export function rootCases() {
+    return CASES;
+}
+export function getTotalCases() {
+    return totalCases;
+}
+export function describe(title, block) {
+    logger.debug(`describe(${title})`);
+    push(title);
+    block();
+    pop();
+}
+export function it(title, block) {
+    logger.debug(`it(${title})`);
+    totalCases += 1;
+    cases[0][title] = block;
+}
+export function beforeEach(fn) {
+    cases[0][beforeeach] = fn;
+}
+export function beforeAll(fn) {
+    cases[0][beforeall] = fn;
+}
+export function afterEach(fn) {
+    cases[0][aftereach] = fn;
+}
+export function afterAll(fn) {
+    cases[0][afterall] = fn;
+}
+export function cleanState(init, runner = beforeEach) {
+    const state = {};
+    runner(() => {
+        Object.assign(state, init());
+    });
+    return state;
+}

package/build/scope/display/console.d.ts

@@ -0,0 +1,2 @@
+import { TestResult } from "../scope.js";
+export declare function onConsole(results: TestResult): void;

package/build/scope/display/console.js

@@ -0,0 +1,21 @@
+import { getLogger } from "../../log.js";
+import { getTotalCases } from "../describe.js";
+import { flattenResults } from "../execute.js";
+const logger = getLogger("Scope Test Runner");
+export function onConsole(results) {
+    const { executed, failed } = results;
+    logger.info("Executed test suite.", {
+        executed,
+        total: getTotalCases(),
+        failed,
+    });
+    const flat = flattenResults(results);
+    for (const { test } of flat) {
+        logger.debug(test);
+    }
+    for (const { test, stack } of flat) {
+        if (stack) {
+            logger.error(test, { stack });
+        }
+    }
+}

package/build/scope/display/dom.d.ts

@@ -0,0 +1,3 @@
+import { DOMElement, Updatable } from "../../dom/dom.js";
+import { TestResult } from "../scope.js";
+export declare function displayStatistics(results: TestResult, root?: Updatable<DOMElement>): void;