@davidsouther/jiffies 2.2.5 → 2.3.0

package/lib/esm/scope/describe.js

@@ -1,60 +0,0 @@
-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.js

@@ -1,21 +0,0 @@
-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.js

@@ -1,26 +0,0 @@
-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.js

@@ -1,17 +0,0 @@
-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.js

@@ -1,85 +0,0 @@
-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.js

@@ -1,104 +0,0 @@
-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 (e) {
-            assert((e.message ?? "").match(message) !== null, () => `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 (e) {
-            assert((e.message ?? "").match(message) !== null, () => `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.js

@@ -1,22 +0,0 @@
-/**
- * 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.js

@@ -1,3 +0,0 @@
-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.js

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

package/lib/esm/scope/state.js

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

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

@@ -1,23 +0,0 @@
-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.js

@@ -1,50 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { contentResponse } from "./response.js";
-// @ts-ignore
-import sass from "sass";
-const { compileStringAsync } = sass;
-function render(source) {
-    // Replace `from "@scope` with `from "/@scope`, for browsers
-    // source = source
-    //   .replaceAll(`from "@`, 'from "/@')
-    //   .replaceAll(`import("@`, 'import("/@');
-    return contentResponse(source, "text/css");
-}
-async function compile(filename, root, vars) {
-    vars = vars.substring(1).replaceAll("=", ":");
-    filename = filename.replaceAll("\\", "/"); // Normalize for dart-sass
-    const sassString = `// Using variables: ${vars}\n${vars};\n@import "${filename}";`;
-    return (await compileStringAsync(sassString, { loadPaths: [root] })).css;
-}
-/**
- * Serves .css files statically. Finds .sass files and transpiles them to css.
- */
-export const cssFileServer = async ({ root, scopes = {} }) => async (req) => {
-    const Url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-    if (Url.pathname.endsWith(".css")) {
-        let scope = Object.entries(scopes).find(([s]) => Url.pathname.startsWith(`/${s}`));
-        // Expand url with found scope
-        Url.protocol = "file";
-        let url = scope ? Url.pathname.replace(scope[0], scope[1]) : Url.pathname;
-        let filename = path.join(root, url);
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const css = (await fs.readFile(filename)).toString("utf-8");
-                return render(css);
-            }
-        }
-        catch { }
-        filename = filename.replace(/\.css$/, ".scss");
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const css = await compile(filename.replace(root, "."), root, Url.search);
-                return render(css);
-            }
-        }
-        catch { }
-    }
-    return undefined;
-};

package/lib/esm/server/http/index.js

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-import { createServer, } from "http";
-import * as path from "path";
-import { info } from "../../log.js";
-import { findIndex } from "./apps.js";
-import { cssFileServer } from "./css.js";
-import { fileResponse } from "./response.js";
-import { sitemap } from "./sitemap.js";
-import { staticFileServer } from "./static.js";
-import { tsFileServer } from "./typescript.js";
-const notFound = async ({ root }) => async () => fileResponse(
-// path.join(path.dirname(FLAGS.argv0), "404.html"),
-path.join(root, "404.html"), undefined, 404);
-const BASE_MIDDLEWARES = [
-    sitemap,
-    tsFileServer,
-    cssFileServer,
-    staticFileServer,
-    findIndex,
-    notFound,
-];
-const error = (res, message) => {
-    console.error(message);
-    res.statusCode = 500;
-    res.write(message);
-    res.end();
-    return true;
-};
-const sendContent = async (res, { content, contentType, contentLength }) => {
-    res.setHeader("Content-Length", `${contentLength}`);
-    res.setHeader("Content-Type", contentType);
-    await res.write(content);
-    res.end();
-    return true;
-};
-const log = (req) => {
-    const when = new Date().toISOString();
-    const who = req.socket.remoteAddress;
-    const what = req.url;
-    const how = `${req.method} ${what}`;
-    info("Request", { when, who, how });
-};
-export const makeServer = async (config, middlewares = []) => {
-    const handlers = await Promise.all([...middlewares, ...BASE_MIDDLEWARES].map(async (m) => m(config)));
-    const middlewareHandler = async (req, res) => {
-        log(req);
-        let handler;
-        try {
-            for (const middleware of handlers) {
-                handler = await middleware(req);
-                if (handler !== undefined) {
-                    break;
-                }
-            }
-            if (handler) {
-                sendContent(res, await handler());
-            }
-            else {
-                res.end();
-            }
-        }
-        catch (e) {
-            error(res, e.message + "\n" + e.stack);
-        }
-    };
-    // TODO(https)
-    const server = createServer(middlewareHandler);
-    server.on("listening", () => {
-        const { address, port } = server.address();
-        info("Server listening", { address: `http://${address}:${port}` });
-    });
-    return server;
-};

package/lib/esm/server/http/response.js

@@ -1,40 +0,0 @@
-import * as fs from "fs/promises";
-const MIME_TYPES = {
-    js: "text/javascript",
-    json: "text/javascript",
-    css: "text/css",
-    html: "text/html",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    svg: "image/svg+xml",
-    eot: "application/vnd.ms-fontobject",
-    ttf: "application/font-ttf",
-    woff: "application/font-woff",
-    woff2: "application/font-woff2",
-};
-const mime = (basename) => {
-    const extension = basename
-        .substring(basename.lastIndexOf(".") + 1)
-        .toLowerCase();
-    return MIME_TYPES[extension] ?? "application/octet-stream";
-};
-export const fileResponse = (filename, stat, status = 200) => async () => {
-    if (!stat) {
-        stat = await fs.stat(filename);
-    }
-    const content = await fs.readFile(filename);
-    const contentType = mime(filename);
-    const contentLength = stat.size;
-    return { status, contentType, contentLength, content };
-};
-const CHARSET = "utf-8";
-export const contentResponse = (content, contentType, status = 200) => async () => {
-    const contentBuffer = Buffer.from(content, CHARSET);
-    return {
-        content: contentBuffer,
-        contentType: contentType.split(";")[0] + "; charset=" + CHARSET,
-        status,
-        contentLength: contentBuffer.length,
-    };
-};

package/lib/esm/server/http/sitemap.js

@@ -1,42 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { info } from "../../log.js";
-import { contentResponse } from "./response.js";
-const findSiteMap = async (root, prefix = root) => {
-    if (root.startsWith("node_modules")) {
-        return [];
-    }
-    const children = (await fs.readdir(root, { withFileTypes: true })).map(async (entry) => {
-        const next = path
-            .join(root, entry.name)
-            // Normalize separators for web
-            .replaceAll(path.sep, "/");
-        if (entry.isFile()) {
-            if (entry.name === "index.html") {
-                let index = next.replace(prefix, "");
-                info(`Adding to sitemap`, { index });
-                return [index];
-            }
-        }
-        else if (entry.isDirectory()) {
-            if (entry.name.startsWith(".")) {
-                return [];
-            }
-            const flattened = (await Promise.all(await findSiteMap(next, prefix))).flat();
-            return flattened;
-        }
-        return [];
-    });
-    return children;
-};
-export const sitemap = async ({ root }) => {
-    const apps = await (await Promise.all(await findSiteMap(root)))
-        .flat()
-        .filter((a) => a !== undefined);
-    return async (req) => {
-        if ((req.url ?? "").endsWith("sitemap.json")) {
-            return contentResponse(JSON.stringify(apps), "application/json");
-        }
-        return undefined;
-    };
-};

package/lib/esm/server/http/static.js

@@ -1,21 +0,0 @@
-import * as path from "path";
-import * as fs from "fs/promises";
-import { fileResponse } from "./response.js";
-export const staticFileServer = async ({ root, scopes = {} }) => async (req) => {
-    const scope = Object.entries(scopes).find(([s]) => req.url?.startsWith(`/${s}`));
-    const url = new URL(req.url ?? "", `http://localhost`);
-    const pathname = scope
-        ? url.pathname.replace(scope[0], scope[1])
-        : url.pathname;
-    const filename = path.join(root, pathname);
-    // Expand url with found scope
-    console.log(scope, req.url, filename);
-    try {
-        const stat = await fs.stat(filename);
-        return stat.isDirectory() ? undefined : fileResponse(filename, stat);
-    }
-    catch (e) {
-        console.error(e);
-        return undefined;
-    }
-};

package/lib/esm/server/http/typescript.js

@@ -1,40 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { contentResponse } from "./response.js";
-import { transpile } from "../../transpile.mjs";
-function render(source) {
-    // Replace `from "@scope` with `from "/@scope`, for browsers
-    source = source
-        .replaceAll(`from "@`, 'from "/@')
-        .replaceAll(`import("@`, 'import("/@');
-    return contentResponse(source, "application/javascript");
-}
-/**
- * Serves .js files statically. Finds .ts files and transpiles them to JS.
- */
-export const tsFileServer = async ({ root, scopes = {} }) => async (req) => {
-    if (req.url?.endsWith(".js")) {
-        let scope = Object.entries(scopes).find(([s]) => req.url?.startsWith(`/${s}`));
-        // Expand url with found scope
-        let url = scope ? req.url.replace(scope[0], scope[1]) : req.url;
-        let filename = path.join(root, url);
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const js = (await fs.readFile(filename)).toString("utf-8");
-                return render(js);
-            }
-        }
-        catch { }
-        filename = filename.replace(/\.js$/, ".ts");
-        try {
-            const stat = await fs.stat(filename);
-            if (stat.isFile()) {
-                const js = await transpile(filename, () => fs.readFile(filename));
-                return render(js);
-            }
-        }
-        catch { }
-    }
-    return undefined;
-};

package/lib/esm/server/main.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node --experimental-loader ../loader.mjs
-import { info } from "../log.js";
-info("Starting server", { cwd: process.cwd() });
-import { parse } from "../flags.js";
-const FLAGS = parse(process.argv);
-import { makeServer } from "./http/index.js";
-import * as path from "node:path";
-async function main() {
-    const server = await makeServer({ root: path.join(process.cwd(), "src") });
-    server.listen(FLAGS.asNumber("port", 8080), FLAGS.asString("host", "0.0.0.0"));
-}
-main();