@davidsouther/jiffies 1.1.0 → 2.0.2

package/{build → lib/esm}/scope/execute.js

@@ -1,85 +1,85 @@
-import { afterall, aftereach, beforeall, beforeeach, rootCases, } from "./describe.js";
-export async function execute(prefix = "", cases = rootCases()) {
-    const beforeallfn = cases[beforeall] ?? (() => { });
-    const beforeeachfn = cases[beforeeach] ?? (() => { });
-    const afterallfn = cases[afterall] ?? (() => { });
-    const aftereachfn = cases[aftereach] ?? (() => { });
-    const result = { executed: 0, passed: 0, failed: 0, total: 0 };
-    try {
-        await beforeallfn();
-    }
-    catch (e) {
-        result["_beforeAll"] = { error: e };
-        return result;
-    }
-    for (const [title, block] of Object.entries(cases)) {
-        if (typeof title === "symbol") {
-            continue;
-        }
-        if (block instanceof Function) {
-            try {
-                result.executed += 1;
-                await beforeeachfn();
-                await block();
-                await aftereachfn();
-                result.passed += 1;
-                result[title] = { passed: true };
-            }
-            catch (e) {
-                result.failed += 1;
-                result[title] = { error: /** @type Error */ e };
-            }
-        }
-        else if (block) {
-            const run = await execute(title, block);
-            result.executed += run.executed;
-            result.passed += run.passed;
-            result.failed += run.failed;
-            result[title] = run;
-        }
-    }
-    try {
-        await afterallfn();
-    }
-    catch (e) {
-        result["_afterAll"] = { error: e };
-    }
-    return result;
-}
-export function getError({ error }) {
-    if (typeof error == "string") {
-        return error;
-    }
-    else if (error.message) {
-        return error.stack;
-    }
-    else {
-        return "unknown error";
-    }
-}
-function makeResult(test, result) {
-    if (result.error)
-        return [
-            {
-                test,
-                stack: getError(result),
-                stats: { executed: 1, failed: 1 },
-            },
-        ];
-    if (result.passed === true) {
-        return [{ test, stats: { executed: 1, failed: 0 } }];
-    }
-    return flattenResults(result, test);
-}
-export function flattenResults(results, prefix = "") {
-    const arrow = prefix == "" ? "" : " -> ";
-    let errorList = [];
-    for (const [title, result] of Object.entries(results).filter(([key]) => !["executed", "passed", "failed"].includes(key))) {
-        const test = `${prefix}${arrow}${title}`;
-        if (typeof result == "number")
-            continue;
-        const flatResult = makeResult(test, result);
-        errorList = errorList.concat(flatResult);
-    }
-    return errorList;
-}
+import { afterall, aftereach, beforeall, beforeeach, rootCases, } from "./describe.js";
+export async function execute(cases = rootCases()) {
+    const beforeallfn = cases[beforeall] ?? (() => { });
+    const beforeeachfn = cases[beforeeach] ?? (() => { });
+    const afterallfn = cases[afterall] ?? (() => { });
+    const aftereachfn = cases[aftereach] ?? (() => { });
+    const result = { executed: 0, passed: 0, failed: 0, total: 0 };
+    try {
+        await beforeallfn();
+    }
+    catch (e) {
+        result["_beforeAll"] = { error: e };
+        return result;
+    }
+    for (const [title, block] of Object.entries(cases)) {
+        if (typeof title === "symbol") {
+            continue;
+        }
+        if (block instanceof Function) {
+            try {
+                result.executed += 1;
+                await beforeeachfn();
+                await block();
+                await aftereachfn();
+                result.passed += 1;
+                result[title] = { passed: true };
+            }
+            catch (e) {
+                result.failed += 1;
+                result[title] = { error: /** @type Error */ e };
+            }
+        }
+        else if (block) {
+            const run = await execute(block);
+            result.executed += run.executed;
+            result.passed += run.passed;
+            result.failed += run.failed;
+            result[title] = run;
+        }
+    }
+    try {
+        await afterallfn();
+    }
+    catch (e) {
+        result["_afterAll"] = { error: e };
+    }
+    return result;
+}
+export function getError({ error }) {
+    if (typeof error == "string") {
+        return error;
+    }
+    else if (error.message) {
+        return error.stack;
+    }
+    else {
+        return "unknown error";
+    }
+}
+function makeResult(test, result) {
+    if (result.error)
+        return [
+            {
+                test,
+                stack: getError(result),
+                stats: { executed: 1, failed: 1 },
+            },
+        ];
+    if (result.passed === true) {
+        return [{ test, stats: { executed: 1, failed: 0 } }];
+    }
+    return flattenResults(result, test);
+}
+export function flattenResults(results, prefix = "") {
+    const arrow = prefix == "" ? "" : " -> ";
+    let errorList = [];
+    for (const [title, result] of Object.entries(results).filter(([key]) => !["executed", "passed", "failed"].includes(key))) {
+        const test = `${prefix}${arrow}${title}`;
+        if (typeof result == "number")
+            continue;
+        const flatResult = makeResult(test, result);
+        errorList = errorList.concat(flatResult);
+    }
+    return errorList;
+}

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

@@ -0,0 +1,23 @@
+export declare class Matcher<T> {
+    actual: T;
+    constructor(actual: T);
+    get not(): Matcher<T>;
+    toBe(expected: T): void;
+    toEqual(expected: T, partial?: boolean): void;
+    toMatch(expected: RegExp | string): void;
+    toMatchObject(expected: Partial<T>): void;
+    toBeNull(): void;
+    toThrow(message?: string): void;
+}
+export declare class NotMatcher<T> {
+    actual: T;
+    constructor(actual: T);
+    get not(): Matcher<T>;
+    toBe(expected: T): void;
+    toEqual(expected: T): void;
+    toMatch(expected: RegExp | string): void;
+    toMatchObject(expected: Partial<T>): void;
+    toBeNull(): void;
+    toThrow(message?: string): void;
+}
+export declare function expect<T>(t: T): Matcher<T>;

package/{build → lib/esm}/scope/expect.js

@@ -1,108 +1,108 @@
-import { assert } from "../assert.js";
-import { display } from "../display.js";
-import { equals } from "../equal.js";
-export class Matcher {
-    actual;
-    constructor(actual) {
-        this.actual = actual;
-    }
-    get not() {
-        return new NotMatcher(this.actual);
-    }
-    toBe(expected) {
-        assert(this.actual === expected, () => `${this.actual} !== ${expected}`);
-    }
-    toEqual(expected, partial = false) {
-        assert(equals(this.actual, expected, partial), () => `Objects are not equivalent: ${display(this.actual)}, ${display(expected)}`);
-    }
-    toMatch(expected) {
-        assert(typeof this.actual === "string", () => "Must have string for regexp match");
-        // @ts-expect-error
-        const actual = this.actual;
-        if (typeof expected === "string") {
-            assert(actual.includes(expected), () => `${actual} does not include ${expected}`);
-        }
-        else {
-            assert(expected.test(actual), () => `${actual} does not match ${expected}`);
-        }
-    }
-    toMatchObject(expected) {
-        for (const [k, v] of Object.entries(expected)) {
-            // @ts-expect-error
-            const actual = this.actual[k];
-            assert(equals(actual, v, true), () => `Comparing ${k}, properties not equal: ${display(actual)}, ${display(v)}`);
-        }
-    }
-    toBeNull() {
-        assert(this.actual === null, () => `Expected null, got ${JSON.stringify(this.actual)}`);
-    }
-    toThrow(message = "") {
-        let didThrow = false;
-        let result = undefined;
-        try {
-            // @ts-expect-error
-            result = this.actual();
-        }
-        catch ({ message: e }) {
-            assert(
-            // @ts-expect-error
-            (e ?? "").match(message), () => `Expected thrown message to match ${message}, got ${e}`);
-            didThrow = true;
-        }
-        assert(didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
-    }
-}
-export class NotMatcher {
-    actual;
-    constructor(actual) {
-        this.actual = actual;
-    }
-    get not() {
-        return new Matcher(this.actual);
-    }
-    toBe(expected) {
-        assert(this.actual !== expected, () => `${this.actual} === ${expected}`);
-    }
-    toEqual(expected) {
-        assert(!equals(this.actual, expected), () => `Objects are equivalent: ${JSON.stringify(this.actual)}, ${JSON.stringify(expected)}`);
-    }
-    toMatch(expected) {
-        assert(typeof this.actual === "string", () => "Must have string for regexp match");
-        // @ts-expect-error
-        const actual = this.actual;
-        if (typeof expected === "string") {
-            assert(!actual.includes(expected), () => `${actual} includes ${expected}`);
-        }
-        else {
-            assert(!expected.test(actual), () => `${actual} matches ${expected}`);
-        }
-    }
-    toMatchObject(expected) {
-        for (const [k, v] of Object.entries(expected)) {
-            // @ts-expect-error
-            const actual = this.actual[k];
-            assert(!equals(actual, v), () => `Comparing ${k}, properties equal: ${JSON.stringify(actual)}, ${JSON.stringify(v)}`);
-        }
-    }
-    toBeNull() {
-        assert(this.actual !== null, () => `Expected not null`);
-    }
-    toThrow(message = "") {
-        let didThrow = false;
-        let result = undefined;
-        try {
-            // @ts-expect-error
-            result = this.actual();
-        }
-        catch ({ message: e }) {
-            assert(
-            // @ts-expect-error
-            (e ?? "").match(message), () => `Expected thrown message to match ${message}, got ${e}`);
-            didThrow = true;
-        }
-        assert(!didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
-    }
-}
-export function expect(t) {
-    return new Matcher(t);
-}
+import { assert } from "../assert.js";
+import { display } from "../display.js";
+import { equals } from "../equal.js";
+export class Matcher {
+    actual;
+    constructor(actual) {
+        this.actual = actual;
+    }
+    get not() {
+        return new NotMatcher(this.actual);
+    }
+    toBe(expected) {
+        assert(this.actual === expected, () => `${this.actual} !== ${expected}`);
+    }
+    toEqual(expected, partial = false) {
+        assert(equals(this.actual, expected, partial), () => `Objects are not equivalent: ${display(this.actual)}, ${display(expected)}`);
+    }
+    toMatch(expected) {
+        assert(typeof this.actual === "string", () => "Must have string for regexp match");
+        // @ts-expect-error
+        const actual = this.actual;
+        if (typeof expected === "string") {
+            assert(actual.includes(expected), () => `${actual} does not include ${expected}`);
+        }
+        else {
+            assert(expected.test(actual), () => `${actual} does not match ${expected}`);
+        }
+    }
+    toMatchObject(expected) {
+        for (const [k, v] of Object.entries(expected)) {
+            // @ts-expect-error
+            const actual = this.actual[k];
+            assert(equals(actual, v, true), () => `Comparing ${k}, properties not equal: ${display(actual)}, ${display(v)}`);
+        }
+    }
+    toBeNull() {
+        assert(this.actual === null, () => `Expected null, got ${JSON.stringify(this.actual)}`);
+    }
+    toThrow(message = "") {
+        let didThrow = false;
+        let result = undefined;
+        try {
+            // @ts-expect-error
+            result = this.actual();
+        }
+        catch ({ message: e }) {
+            assert(
+            // @ts-expect-error
+            (e ?? "").match(message), () => `Expected thrown message to match ${message}, got ${e}`);
+            didThrow = true;
+        }
+        assert(didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
+    }
+}
+export class NotMatcher {
+    actual;
+    constructor(actual) {
+        this.actual = actual;
+    }
+    get not() {
+        return new Matcher(this.actual);
+    }
+    toBe(expected) {
+        assert(this.actual !== expected, () => `${this.actual} === ${expected}`);
+    }
+    toEqual(expected) {
+        assert(!equals(this.actual, expected), () => `Objects are equivalent: ${JSON.stringify(this.actual)}, ${JSON.stringify(expected)}`);
+    }
+    toMatch(expected) {
+        assert(typeof this.actual === "string", () => "Must have string for regexp match");
+        // @ts-expect-error
+        const actual = this.actual;
+        if (typeof expected === "string") {
+            assert(!actual.includes(expected), () => `${actual} includes ${expected}`);
+        }
+        else {
+            assert(!expected.test(actual), () => `${actual} matches ${expected}`);
+        }
+    }
+    toMatchObject(expected) {
+        for (const [k, v] of Object.entries(expected)) {
+            // @ts-expect-error
+            const actual = this.actual[k];
+            assert(!equals(actual, v), () => `Comparing ${k}, properties equal: ${JSON.stringify(actual)}, ${JSON.stringify(v)}`);
+        }
+    }
+    toBeNull() {
+        assert(this.actual !== null, () => `Expected not null`);
+    }
+    toThrow(message = "") {
+        let didThrow = false;
+        let result = undefined;
+        try {
+            // @ts-expect-error
+            result = this.actual();
+        }
+        catch ({ message: e }) {
+            assert(
+            // @ts-expect-error
+            (e ?? "").match(message), () => `Expected thrown message to match ${message}, got ${e}`);
+            didThrow = true;
+        }
+        assert(!didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
+    }
+}
+export function expect(t) {
+    return new Matcher(t);
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Given a value with numbers, attempt to fix all numbers to 1 decimal point.
+ */
+export declare function fix<T>(n: T): T;

package/{build → lib/esm}/scope/fix.js

@@ -1,22 +1,22 @@
-/**
- * Given a value with numbers, attempt to fix all numbers to 1 decimal point.
- */
-export function fix(n) {
-    if (typeof n === "number") {
-        // @ts-ignore
-        return +n.toFixed(1);
-    }
-    if (n !== Object(n)) {
-        // A primitive
-        return n;
-    }
-    if (n instanceof Array) {
-        // @ts-ignore
-        return n.map(fix);
-    }
-    // @ts-ignore
-    return mapreduce(fix, n);
-}
-function mapreduce(fn, iter) {
-    return Object.entries(iter).reduce((acc, [k, v]) => ((acc[k] = fn(v)), acc), {});
-}
+/**
+ * Given a value with numbers, attempt to fix all numbers to 1 decimal point.
+ */
+export function fix(n) {
+    if (typeof n === "number") {
+        // @ts-ignore
+        return +n.toFixed(1);
+    }
+    if (n !== Object(n)) {
+        // A primitive
+        return n;
+    }
+    if (n instanceof Array) {
+        // @ts-ignore
+        return n.map(fix);
+    }
+    // @ts-ignore
+    return mapreduce(fix, n);
+}
+function mapreduce(fn, iter) {
+    return Object.entries(iter).reduce((acc, [k, v]) => ((acc[k] = fn(v)), acc), {});
+}

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

@@ -0,0 +1,3 @@
+export { expect } from "./expect.js";
+export { fix } from "./fix.js";
+export { afterAll, afterEach, beforeAll, beforeEach, cleanState, describe, it, } from "./describe.js";

package/{build → lib/esm}/scope/index.js

@@ -1,3 +1,3 @@
-export { expect } from "./expect.js";
-export { fix } from "./fix.js";
-export { afterAll, afterEach, beforeAll, beforeEach, cleanState, describe, it, } from "./describe.js";
+export { expect } from "./expect.js";
+export { fix } from "./fix.js";
+export { afterAll, afterEach, beforeAll, beforeEach, cleanState, describe, it, } from "./describe.js";

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

@@ -0,0 +1,17 @@
+export interface TestCase {
+    [k: string]: Function | TestCase;
+    [k: symbol]: Function;
+}
+export interface TestResult {
+    executed: number;
+    passed: number;
+    failed: number;
+    [k: string]: TestResult | TestSummary | number;
+}
+export declare type TestSummary = TestFailed | TestPassed;
+export interface TestFailed {
+    error: unknown;
+}
+export interface TestPassed {
+    passed: true;
+}

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

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

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

@@ -0,0 +1 @@
+export declare function cleanState<State extends {}>(init: () => State, runner: (action: () => void) => void): State;

package/lib/esm/scope/state.js

@@ -0,0 +1,7 @@
+export function cleanState(init, runner) {
+    const state = {};
+    runner(() => {
+        Object.assign(state, init());
+    });
+    return state;
+}

package/lib/esm/server/http/apps.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareFactory } from "./index.js";
+/**
+ * Searches up the request path until the first index is found.
+ */
+export declare const findIndex: MiddlewareFactory;

package/{build → lib/esm}/server/http/apps.js

@@ -1,23 +1,23 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { fileResponse } from "./response.js";
-/**
- * Searches up the request path until the first index is found.
- */
-export const findIndex = async ({ root }) => async (req) => {
-    let filename = path.join(root, req.url ?? "");
-    if (path.basename(filename).match(/\.[a-z]{1,3}$/)) {
-        return undefined;
-    }
-    while (filename.startsWith(root)) {
-        const index = path.join(filename, "index.html");
-        try {
-            const stat = await fs.stat(index);
-            return fileResponse(index, stat);
-        }
-        catch (e) {
-            filename = path.dirname(filename);
-        }
-    }
-    return undefined;
-};
+import * as fs from "fs/promises";
+import * as path from "path";
+import { fileResponse } from "./response.js";
+/**
+ * Searches up the request path until the first index is found.
+ */
+export const findIndex = async ({ root }) => async (req) => {
+    let filename = path.join(root, req.url ?? "");
+    if (path.basename(filename).match(/\.[a-z]{1,3}$/)) {
+        return undefined;
+    }
+    while (filename.startsWith(root)) {
+        const index = path.join(filename, "index.html");
+        try {
+            const stat = await fs.stat(index);
+            return fileResponse(index, stat);
+        }
+        catch (e) {
+            filename = path.dirname(filename);
+        }
+    }
+    return undefined;
+};

package/lib/esm/server/http/css.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareFactory } from "./index.js";
+/**
+ * Serves .css files statically. Finds .sass files and transpiles them to css.
+ */
+export declare const cssFileServer: MiddlewareFactory;