@davidsouther/jiffies 1.0.0 → 2.0.1

package/lib/cjs/result.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapOrElse = exports.unwrapOr = exports.unwrap = exports.Err = exports.Ok = exports.isResult = exports.isErr = exports.isOk = exports.Some = exports.None = exports.isSome = exports.isNone = void 0;
+const isNone = (s) => s === null;
+exports.isNone = isNone;
+const isSome = (s) => s != null;
+exports.isSome = isSome;
+function None(_) {
+    return null;
+}
+exports.None = None;
+function Some(t) {
+    return t;
+}
+exports.Some = Some;
+const isOk = (t) => t.ok !== undefined;
+exports.isOk = isOk;
+const isErr = (e) => e.err !== undefined;
+exports.isErr = isErr;
+const isResult = (t) => (0, exports.isOk)(t) || (0, exports.isErr)(t);
+exports.isResult = isResult;
+function Ok(t) {
+    return t.ok
+        ? t.ok
+        : {
+            ok: t,
+            map(fn) {
+                return fn(Ok(this));
+            },
+        };
+}
+exports.Ok = Ok;
+function Err(e) {
+    return (e.err ?? {
+        err: e,
+        map(_fn) {
+            return this;
+        },
+    });
+}
+exports.Err = Err;
+function unwrap(t) {
+    if ((0, exports.isNone)(t)) {
+        throw new Error(`Attempted to unwrap None`);
+    }
+    if ((0, exports.isErr)(t)) {
+        throw Err(t);
+    }
+    if ((0, exports.isOk)(t)) {
+        return Ok(t);
+    }
+    return t;
+}
+exports.unwrap = unwrap;
+function unwrapOr(t, def) {
+    if ((0, exports.isNone)(t)) {
+        return def;
+    }
+    if ((0, exports.isErr)(t)) {
+        return def;
+    }
+    if ((0, exports.isOk)(t)) {
+        return Ok(t);
+    }
+    return t;
+}
+exports.unwrapOr = unwrapOr;
+function unwrapOrElse(t, def) {
+    if ((0, exports.isNone)(t)) {
+        return def();
+    }
+    if ((0, exports.isErr)(t)) {
+        return def();
+    }
+    if ((0, exports.isOk)(t)) {
+        return Ok(t);
+    }
+    return t;
+}
+exports.unwrapOrElse = unwrapOrElse;

package/lib/cjs/result.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const result_js_1 = require("./result.js");
+const describe_js_1 = require("./scope/describe.js");
+const expect_js_1 = require("./scope/expect.js");
+(0, describe_js_1.describe)("Result", () => {
+    (0, describe_js_1.it)("converts Nones", () => {
+        const a = (0, result_js_1.None)();
+        (0, expect_js_1.expect)(a).toBeNull();
+        const b = (0, result_js_1.None)();
+        (0, expect_js_1.expect)(b).toBeNull();
+        const c = (0, result_js_1.Some)(a);
+        (0, expect_js_1.expect)(c).toBeNull();
+        const d = (0, result_js_1.Some)(b);
+        (0, expect_js_1.expect)(d).toBeNull();
+    });
+    (0, describe_js_1.it)("converts Somes", () => {
+        const a = (0, result_js_1.Some)("a");
+        (0, expect_js_1.expect)(a).toBe("a");
+        const b = (0, result_js_1.Some)(a);
+        (0, expect_js_1.expect)(b).toBe("a");
+    });
+    (0, describe_js_1.it)("converts Errs", () => {
+        const a = (0, result_js_1.Err)(new Error("a error"));
+        const b = (0, result_js_1.Err)(a);
+        (0, expect_js_1.expect)(b).toMatchObject({ message: "a error" });
+        // Assign Err to Result
+        const c = a;
+    });
+    (0, describe_js_1.it)("converts Oks", () => {
+        const a = (0, result_js_1.Ok)("a ok");
+        const b = (0, result_js_1.Ok)(a);
+        (0, expect_js_1.expect)(b).toBe("a ok");
+        // Assign ok to Result
+        const c = a;
+    });
+    (0, describe_js_1.it)("unwraps", () => {
+        const a = (0, result_js_1.Some)("some");
+        const b = (0, result_js_1.None)();
+        const c = (0, result_js_1.Ok)("ok");
+        const d = (0, result_js_1.Err)(new Error("err"));
+        const e = "else";
+        (0, expect_js_1.expect)((0, result_js_1.unwrap)(a)).toBe("some");
+        (0, expect_js_1.expect)((0, result_js_1.unwrap)(c)).toBe("ok");
+        (0, expect_js_1.expect)(() => (0, result_js_1.unwrap)(b)).toThrow("Attempted to unwrap None");
+        (0, expect_js_1.expect)(() => (0, result_js_1.unwrap)(d)).toThrow("err");
+        (0, expect_js_1.expect)((0, result_js_1.unwrap)(e)).toBe("else");
+    });
+    (0, describe_js_1.it)("unwrapsOrs", () => {
+        const a = (0, result_js_1.Some)("some");
+        const b = (0, result_js_1.None)();
+        const c = (0, result_js_1.Ok)("ok");
+        const d = (0, result_js_1.Err)(new Error("err"));
+        const e = "else";
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOr)(a, "z")).toBe("some");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOr)(c, "z")).toBe("ok");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOr)(b, "z")).toBe("z");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOr)(d, "z")).toBe("z");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOr)(e, "z")).toBe("else");
+    });
+    (0, describe_js_1.it)("unwrapsOrElse", () => {
+        const a = (0, result_js_1.Some)("some");
+        const b = (0, result_js_1.None)();
+        const c = (0, result_js_1.Ok)("ok");
+        const d = (0, result_js_1.Err)(new Error("err"));
+        const e = "else";
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOrElse)(a, () => "z")).toBe("some");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOrElse)(c, () => "z")).toBe("ok");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOrElse)(b, () => "z")).toBe("z");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOrElse)(d, () => "z")).toBe("z");
+        (0, expect_js_1.expect)((0, result_js_1.unwrapOrElse)(e, () => "z")).toBe("else");
+    });
+});

package/lib/cjs/safe.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safe = void 0;
+const log_js_1 = require("./log.js");
+const safe = (fn, r) => (...args) => {
+    try {
+        return fn(...args);
+    }
+    catch (e) {
+        (0, log_js_1.error)(`${e}`);
+        return r;
+    }
+};
+exports.safe = safe;

package/{build → lib/cjs}/scope/describe.d.ts

@@ -5,8 +5,12 @@ 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;

package/lib/cjs/scope/describe.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanState = exports.afterAll = exports.afterEach = exports.beforeAll = exports.beforeEach = exports.it = exports.describe = exports.getSkippedCases = exports.getTotalCases = exports.rootCases = exports.aftereach = exports.afterall = exports.beforeeach = exports.beforeall = void 0;
+const assert_js_1 = require("../assert.js");
+const log_js_1 = require("../log.js");
+const state = require("./state.js");
+exports.beforeall = Symbol("beforeAll");
+exports.beforeeach = Symbol("beforeEach");
+exports.afterall = Symbol("afterAll");
+exports.aftereach = Symbol("afterEach");
+const logger = (0, log_js_1.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();
+}
+function rootCases() {
+    return CASES;
+}
+exports.rootCases = rootCases;
+function getTotalCases() {
+    return totalCases;
+}
+exports.getTotalCases = getTotalCases;
+function getSkippedCases() {
+    return skippedCases;
+}
+exports.getSkippedCases = getSkippedCases;
+function describe(title, block) {
+    logger.debug(`describe(${title})`);
+    push(title);
+    block();
+    pop();
+}
+exports.describe = describe;
+function it(title, block) {
+    logger.debug(`it(${title})`);
+    (0, assert_js_1.assert)(cases[0][title] == undefined, `Block already has test ${title}`);
+    totalCases += 1;
+    cases[0][title] = block;
+}
+exports.it = it;
+it.skip = (title, _block) => {
+    logger.debug(`it.skip(${title})`);
+    totalCases += 1;
+    skippedCases += 1;
+};
+function beforeEach(fn) {
+    cases[0][exports.beforeeach] = fn;
+}
+exports.beforeEach = beforeEach;
+function beforeAll(fn) {
+    cases[0][exports.beforeall] = fn;
+}
+exports.beforeAll = beforeAll;
+function afterEach(fn) {
+    cases[0][exports.aftereach] = fn;
+}
+exports.afterEach = afterEach;
+function afterAll(fn) {
+    cases[0][exports.afterall] = fn;
+}
+exports.afterAll = afterAll;
+function cleanState(init, runner = beforeEach) {
+    return state.cleanState(init, runner);
+}
+exports.cleanState = cleanState;

package/lib/cjs/scope/display/console.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onConsole = void 0;
+const log_js_1 = require("../../log.js");
+const describe_js_1 = require("../describe.js");
+const execute_js_1 = require("../execute.js");
+const logger = (0, log_js_1.getLogger)("Scope Test Runner");
+function onConsole(results) {
+    const { executed, failed } = results;
+    logger.info("Executed test suite.", {
+        executed,
+        total: (0, describe_js_1.getTotalCases)(),
+        failed,
+    });
+    const flat = (0, execute_js_1.flattenResults)(results);
+    for (const { test } of flat) {
+        logger.debug(test);
+    }
+    for (const { test, stack } of flat) {
+        if (stack) {
+            logger.error(test, { stack });
+        }
+    }
+}
+exports.onConsole = onConsole;

package/{build → lib/cjs}/scope/display/dom.d.ts

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

package/lib/cjs/scope/display/dom.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayStatistics = void 0;
+const logger_js_1 = require("../../components/logger.js");
+const log_js_1 = require("../../log.js");
+const describe_js_1 = require("../describe.js");
+const execute_js_1 = require("../execute.js");
+function displayStatistics(results, root = document.body) {
+    const { executed, failed } = results;
+    const logger = (() => {
+        try {
+            return (0, logger_js_1.makeHTMLLogger)(`Executed ${executed} of ${(0, describe_js_1.getTotalCases)()}; ${failed} failed.`);
+        }
+        catch (e) {
+            return log_js_1.DEFAULT_LOGGER;
+        }
+    })();
+    logger.level = log_js_1.LEVEL.DEBUG;
+    const flat = (0, execute_js_1.flattenResults)(results);
+    for (const { test, stack } of flat) {
+        if (stack) {
+            logger.info(test);
+            logger.debug(`${stack}`);
+        }
+    }
+    if ((0, logger_js_1.isHTMLLogger)(logger)) {
+        root.appendChild(logger.root);
+    }
+}
+exports.displayStatistics = displayStatistics;

package/lib/cjs/scope/display/junit.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asXML = void 0;
+const xml_js_1 = require("../../dom/xml.js");
+const execute_js_1 = require("../execute.js");
+const cases = (results) => Object.entries(results).filter(([key]) => !["executed", "passed", "failed"].includes(key));
+function asXML(results) {
+    return (`<?xml version="1.0" encoding="UTF-8" ?>` +
+        (0, xml_js_1.xml)("testsuites", { tests: results.executed, failures: results.failed }, cases(results).map(([title, children]) => testsuite(title, children.executed, children.failed, (0, execute_js_1.flattenResults)(children)))));
+}
+exports.asXML = asXML;
+function testsuite(name, tests, failures, cases) {
+    const id = name.replace("s+", "_");
+    return (0, xml_js_1.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 (0, xml_js_1.xml)("testcase", { id, name, time }, failures.map((stack) => failure({ text: stack })));
+}
+function failure({ text, message = text.split("\n")[0], }) {
+    return (0, xml_js_1.xml)("failure", { message }, [`<![CDATA[${text}]]>`]);
+}

package/{build → lib/cjs}/scope/execute.d.ts

@@ -1,5 +1,5 @@
 import { TestResult, TestSummary } from "./scope.js";
-export declare function execute(prefix?: string, cases?: import("./scope.js").TestCase): Promise<TestResult>;
+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;

package/lib/cjs/scope/execute.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenResults = exports.getError = exports.execute = void 0;
+const describe_js_1 = require("./describe.js");
+async function execute(cases = (0, describe_js_1.rootCases)()) {
+    const beforeallfn = cases[describe_js_1.beforeall] ?? (() => { });
+    const beforeeachfn = cases[describe_js_1.beforeeach] ?? (() => { });
+    const afterallfn = cases[describe_js_1.afterall] ?? (() => { });
+    const aftereachfn = cases[describe_js_1.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;
+}
+exports.execute = execute;
+function getError({ error }) {
+    if (typeof error == "string") {
+        return error;
+    }
+    else if (error.message) {
+        return error.stack;
+    }
+    else {
+        return "unknown error";
+    }
+}
+exports.getError = getError;
+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);
+}
+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;
+}
+exports.flattenResults = flattenResults;

package/lib/cjs/scope/expect.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expect = exports.NotMatcher = exports.Matcher = void 0;
+const assert_js_1 = require("../assert.js");
+const display_js_1 = require("../display.js");
+const equal_js_1 = require("../equal.js");
+class Matcher {
+    actual;
+    constructor(actual) {
+        this.actual = actual;
+    }
+    get not() {
+        return new NotMatcher(this.actual);
+    }
+    toBe(expected) {
+        (0, assert_js_1.assert)(this.actual === expected, () => `${this.actual} !== ${expected}`);
+    }
+    toEqual(expected, partial = false) {
+        (0, assert_js_1.assert)((0, equal_js_1.equals)(this.actual, expected, partial), () => `Objects are not equivalent: ${(0, display_js_1.display)(this.actual)}, ${(0, display_js_1.display)(expected)}`);
+    }
+    toMatch(expected) {
+        (0, assert_js_1.assert)(typeof this.actual === "string", () => "Must have string for regexp match");
+        // @ts-expect-error
+        const actual = this.actual;
+        if (typeof expected === "string") {
+            (0, assert_js_1.assert)(actual.includes(expected), () => `${actual} does not include ${expected}`);
+        }
+        else {
+            (0, assert_js_1.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];
+            (0, assert_js_1.assert)((0, equal_js_1.equals)(actual, v, true), () => `Comparing ${k}, properties not equal: ${(0, display_js_1.display)(actual)}, ${(0, display_js_1.display)(v)}`);
+        }
+    }
+    toBeNull() {
+        (0, assert_js_1.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 }) {
+            (0, assert_js_1.assert)(
+            // @ts-expect-error
+            (e ?? "").match(message), () => `Expected thrown message to match ${message}, got ${e}`);
+            didThrow = true;
+        }
+        (0, assert_js_1.assert)(didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
+    }
+}
+exports.Matcher = Matcher;
+class NotMatcher {
+    actual;
+    constructor(actual) {
+        this.actual = actual;
+    }
+    get not() {
+        return new Matcher(this.actual);
+    }
+    toBe(expected) {
+        (0, assert_js_1.assert)(this.actual !== expected, () => `${this.actual} === ${expected}`);
+    }
+    toEqual(expected) {
+        (0, assert_js_1.assert)(!(0, equal_js_1.equals)(this.actual, expected), () => `Objects are equivalent: ${JSON.stringify(this.actual)}, ${JSON.stringify(expected)}`);
+    }
+    toMatch(expected) {
+        (0, assert_js_1.assert)(typeof this.actual === "string", () => "Must have string for regexp match");
+        // @ts-expect-error
+        const actual = this.actual;
+        if (typeof expected === "string") {
+            (0, assert_js_1.assert)(!actual.includes(expected), () => `${actual} includes ${expected}`);
+        }
+        else {
+            (0, assert_js_1.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];
+            (0, assert_js_1.assert)(!(0, equal_js_1.equals)(actual, v), () => `Comparing ${k}, properties equal: ${JSON.stringify(actual)}, ${JSON.stringify(v)}`);
+        }
+    }
+    toBeNull() {
+        (0, assert_js_1.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 }) {
+            (0, assert_js_1.assert)(
+            // @ts-expect-error
+            (e ?? "").match(message), () => `Expected thrown message to match ${message}, got ${e}`);
+            didThrow = true;
+        }
+        (0, assert_js_1.assert)(!didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
+    }
+}
+exports.NotMatcher = NotMatcher;
+function expect(t) {
+    return new Matcher(t);
+}
+exports.expect = expect;

package/lib/cjs/scope/fix.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fix = void 0;
+/**
+ * Given a value with numbers, attempt to fix all numbers to 1 decimal point.
+ */
+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);
+}
+exports.fix = fix;
+function mapreduce(fn, iter) {
+    return Object.entries(iter).reduce((acc, [k, v]) => ((acc[k] = fn(v)), acc), {});
+}

package/lib/cjs/scope/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.it = exports.describe = exports.cleanState = exports.beforeEach = exports.beforeAll = exports.afterEach = exports.afterAll = exports.fix = exports.expect = void 0;
+var expect_js_1 = require("./expect.js");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return expect_js_1.expect; } });
+var fix_js_1 = require("./fix.js");
+Object.defineProperty(exports, "fix", { enumerable: true, get: function () { return fix_js_1.fix; } });
+var describe_js_1 = require("./describe.js");
+Object.defineProperty(exports, "afterAll", { enumerable: true, get: function () { return describe_js_1.afterAll; } });
+Object.defineProperty(exports, "afterEach", { enumerable: true, get: function () { return describe_js_1.afterEach; } });
+Object.defineProperty(exports, "beforeAll", { enumerable: true, get: function () { return describe_js_1.beforeAll; } });
+Object.defineProperty(exports, "beforeEach", { enumerable: true, get: function () { return describe_js_1.beforeEach; } });
+Object.defineProperty(exports, "cleanState", { enumerable: true, get: function () { return describe_js_1.cleanState; } });
+Object.defineProperty(exports, "describe", { enumerable: true, get: function () { return describe_js_1.describe; } });
+Object.defineProperty(exports, "it", { enumerable: true, get: function () { return describe_js_1.it; } });

package/lib/cjs/scope/scope.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/cjs/scope/state.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanState = void 0;
+function cleanState(init, runner) {
+    const state = {};
+    runner(() => {
+        Object.assign(state, init());
+    });
+    return state;
+}
+exports.cleanState = cleanState;

package/lib/cjs/server/http/apps.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIndex = void 0;
+const fs = require("fs/promises");
+const path = require("path");
+const response_js_1 = require("./response.js");
+/**
+ * Searches up the request path until the first index is found.
+ */
+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 (0, response_js_1.fileResponse)(index, stat);
+        }
+        catch (e) {
+            filename = path.dirname(filename);
+        }
+    }
+    return undefined;
+};
+exports.findIndex = findIndex;