@davidsouther/jiffies 1.0.0-beta.1

package/build/scope/display/dom.js

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

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

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

package/build/scope/display/junit.js

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

package/build/scope/execute.d.ts

@@ -0,0 +1,12 @@
+import { TestResult, TestSummary } from "./scope.js";
+export declare function execute(prefix?: string, 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[];

package/build/scope/execute.js

@@ -0,0 +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) {
+        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/build/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): 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/scope/expect.js

@@ -0,0 +1,107 @@
+import { assert } from "../assert.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) {
+        assert(equals(this.actual, expected), () => `Objects are not 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} 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), () => `Comparing ${k}, properties not equal: ${JSON.stringify(actual)}, ${JSON.stringify(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/build/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/scope/fix.js

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

package/build/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/scope/index.js

@@ -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/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/scope/scope.js

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

package/build/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/server/http/apps.js

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

package/build/server/http/index.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+export interface StaticResponse {
+    status: 200 | 404 | 500;
+    content: Buffer;
+    contentType: string;
+    contentLength?: number;
+}
+export interface ServerConfig {
+    root: string;
+    scopes?: Record<`@${string}`, string>;
+}
+export interface MiddlewareFactory {
+    (config: ServerConfig): Promise<StaticMiddleware>;
+}
+export interface StaticMiddleware {
+    (req: IncomingMessage): Promise<undefined | (() => Promise<StaticResponse>)>;
+}
+export declare const makeServer: (config: ServerConfig, middlewares?: MiddlewareFactory[]) => Promise<import("http").Server>;

package/build/server/http/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { createServer, } from "http";
+import * as path from "path";
+import { info } from "../../log.js";
+import { findIndex } from "./apps.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,
+    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/build/server/http/response.d.ts

@@ -0,0 +1,4 @@
+import { Stats } from "fs";
+import { StaticResponse } from ".";
+export declare const fileResponse: (filename: string, stat?: Stats, status?: 200 | 404 | 500) => () => Promise<StaticResponse>;
+export declare const contentResponse: (content: string, contentType: string, status?: 200 | 404 | 500) => () => Promise<StaticResponse>;

package/build/server/http/response.js

@@ -0,0 +1,37 @@
+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.substr(basename.lastIndexOf(".") + 1);
+    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 };
+};
+export const contentResponse = (content, contentType, status = 200) => async () => {
+    const contentBuffer = Buffer.from(content, "utf-8");
+    return {
+        content: contentBuffer,
+        contentType,
+        status,
+        contentLength: contentBuffer.length,
+    };
+};

package/build/server/http/sitemap.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareFactory } from "./index.js";
+export declare const sitemap: MiddlewareFactory;

package/build/server/http/sitemap.js

@@ -0,0 +1,42 @@
+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/build/server/http/static.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareFactory } from "./index.js";
+export declare const staticFileServer: MiddlewareFactory;

package/build/server/http/static.js

@@ -0,0 +1,21 @@
+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/build/server/http/typescript.d.ts

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

package/build/server/http/typescript.js

@@ -0,0 +1,40 @@
+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/build/server/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node --experimental-loader ../loader.mjs
+export {};

package/build/server/main.js

@@ -0,0 +1,9 @@
+#!/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";
+const server = await makeServer({ root: path.join(process.cwd(), "src") });
+server.listen(FLAGS.asNumber("port", 8080), FLAGS.asString("host", "0.0.0.0"));

package/build/test.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};