@davidsouther/jiffies 1.1.0 → 2.0.2

package/{build → lib/esm}/result.js

@@ -1,65 +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: 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;
-}
+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: 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/lib/esm/result.test.d.ts

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

package/{build → lib/esm}/result.test.js

@@ -1,71 +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");
-    });
-});
+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/lib/esm/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 → lib/esm}/safe.js

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

package/lib/esm/scope/describe.d.ts

@@ -0,0 +1,18 @@
+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 getSkippedCases(): number;
+export declare function describe(title: string, block: Function): void;
+export declare function it(title: string, block: Function): void;
+export declare namespace it {
+    var skip: (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 → lib/esm}/scope/describe.js

@@ -1,61 +1,60 @@
-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;
-let skippedCases = 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 getSkippedCases() {
-    return skippedCases;
-}
-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;
-}
-it.skip = (title, _block) => {
-    logger.debug(`it.skip(${title})`);
-    totalCases += 1;
-    skippedCases += 1;
-};
-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;
-}
+import { assert } from "../assert.js";
+import { getLogger } from "../log.js";
+import * as state from "./state.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;
+let skippedCases = 0;
+function push(title) {
+    const next = (cases[0][title] = cases[0][title] ?? {});
+    cases.unshift(next);
+}
+function pop() {
+    cases.shift();
+}
+export function rootCases() {
+    return CASES;
+}
+export function getTotalCases() {
+    return totalCases;
+}
+export function getSkippedCases() {
+    return skippedCases;
+}
+export function describe(title, block) {
+    logger.debug(`describe(${title})`);
+    push(title);
+    block();
+    pop();
+}
+export function it(title, block) {
+    logger.debug(`it(${title})`);
+    assert(cases[0][title] == undefined, `Block already has test ${title}`);
+    totalCases += 1;
+    cases[0][title] = block;
+}
+it.skip = (title, _block) => {
+    logger.debug(`it.skip(${title})`);
+    totalCases += 1;
+    skippedCases += 1;
+};
+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) {
+    return state.cleanState(init, runner);
+}

package/lib/esm/scope/display/console.d.ts

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

package/{build → lib/esm}/scope/display/console.js

@@ -1,21 +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 });
-        }
-    }
-}
+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/lib/esm/scope/display/dom.d.ts

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

package/{build → lib/esm}/scope/display/dom.js

@@ -1,26 +1,26 @@
-import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js";
-import { DEFAULT_LOGGER, LEVEL } from "../../log.js";
-import { getTotalCases } from "../describe.js";
-import { flattenResults } from "../execute.js";
-export function displayStatistics(results, root = document.body) {
-    const { executed, failed } = results;
-    const logger = (() => {
-        try {
-            return makeHTMLLogger(`Executed ${executed} of ${getTotalCases()}; ${failed} failed.`);
-        }
-        catch (e) {
-            return DEFAULT_LOGGER;
-        }
-    })();
-    logger.level = LEVEL.DEBUG;
-    const flat = flattenResults(results);
-    for (const { test, stack } of flat) {
-        if (stack) {
-            logger.info(test);
-            logger.debug(`${stack}`);
-        }
-    }
-    if (isHTMLLogger(logger)) {
-        root.appendChild(logger.root);
-    }
-}
+import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js";
+import { DEFAULT_LOGGER, LEVEL } from "../../log.js";
+import { getTotalCases } from "../describe.js";
+import { flattenResults } from "../execute.js";
+export function displayStatistics(results, root = document.body) {
+    const { executed, failed } = results;
+    const logger = (() => {
+        try {
+            return makeHTMLLogger(`Executed ${executed} of ${getTotalCases()}; ${failed} failed.`);
+        }
+        catch (e) {
+            return DEFAULT_LOGGER;
+        }
+    })();
+    logger.level = LEVEL.DEBUG;
+    const flat = flattenResults(results);
+    for (const { test, stack } of flat) {
+        if (stack) {
+            logger.info(test);
+            logger.debug(`${stack}`);
+        }
+    }
+    if (isHTMLLogger(logger)) {
+        root.appendChild(logger.root);
+    }
+}

package/lib/esm/scope/display/junit.d.ts

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

package/{build → lib/esm}/scope/display/junit.js

@@ -1,17 +1,17 @@
-import { xml } from "../../dom/xml.js";
-import { flattenResults } from "../execute.js";
-const cases = (results) => Object.entries(results).filter(([key]) => !["executed", "passed", "failed"].includes(key));
-export function asXML(results) {
-    return (`<?xml version="1.0" encoding="UTF-8" ?>` +
-        xml("testsuites", { tests: results.executed, failures: results.failed }, cases(results).map(([title, children]) => testsuite(title, children.executed, children.failed, flattenResults(children)))));
-}
-function testsuite(name, tests, failures, cases) {
-    const id = name.replace("s+", "_");
-    return xml("testsuite", { id, name, tests, failures }, cases.map(({ test, stack }) => testcase({ name: `${name} ${test}` }, stack ? [stack] : [])));
-}
-function testcase({ name, id = name.replace(/\s+/g, "_"), time = "0.00", }, failures) {
-    return xml("testcase", { id, name, time }, failures.map((stack) => failure({ text: stack })));
-}
-function failure({ text, message = text.split("\n")[0], }) {
-    return xml("failure", { message }, [`<![CDATA[${text}]]>`]);
-}
+import { xml } from "../../dom/xml.js";
+import { flattenResults } from "../execute.js";
+const cases = (results) => Object.entries(results).filter(([key]) => !["executed", "passed", "failed"].includes(key));
+export function asXML(results) {
+    return (`<?xml version="1.0" encoding="UTF-8" ?>` +
+        xml("testsuites", { tests: results.executed, failures: results.failed }, cases(results).map(([title, children]) => testsuite(title, children.executed, children.failed, flattenResults(children)))));
+}
+function testsuite(name, tests, failures, cases) {
+    const id = name.replace("s+", "_");
+    return xml("testsuite", { id, name, tests, failures }, cases.map(({ test, stack }) => testcase({ name: `${name} ${test}` }, stack ? [stack] : [])));
+}
+function testcase({ name, id = name.replace(/\s+/g, "_"), time = "0.00", }, failures) {
+    return xml("testcase", { id, name, time }, failures.map((stack) => failure({ text: stack })));
+}
+function failure({ text, message = text.split("\n")[0], }) {
+    return xml("failure", { message }, [`<![CDATA[${text}]]>`]);
+}

package/lib/esm/scope/execute.d.ts

@@ -0,0 +1,12 @@
+import { TestResult, TestSummary } from "./scope.js";
+export declare function execute(cases?: import("./scope.js").TestCase): Promise<TestResult>;
+export declare function getError({ error }: TestResult): number | TestResult | TestSummary | "unknown error";
+export interface FlatResult {
+    test: string;
+    stack?: string | number | TestResult | TestSummary;
+    stats: {
+        executed: number;
+        failed: number;
+    };
+}
+export declare function flattenResults(results: TestResult, prefix?: string): FlatResult[];