velocious 1.0.108 → 1.0.110

package/dist/src/routes/resolver.js

@@ -0,0 +1,92 @@
+// @ts-check
+import { digg } from "diggerize";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import fs from "fs/promises";
+import * as inflection from "inflection";
+export default class VelociousRoutesResolver {
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @param {import("../http-server/client/response.js").default} args.response
+     */
+    constructor({ configuration, request, response }) {
+        if (!configuration)
+            throw new Error("No configuration given");
+        if (!request)
+            throw new Error("No request given");
+        if (!response)
+            throw new Error("No response given");
+        this.configuration = configuration;
+        this.params = request.params();
+        this.request = request;
+        this.response = response;
+    }
+    async resolve() {
+        let controllerPath;
+        let currentRoute = digg(this, "configuration", "routes", "rootRoute");
+        let currentPath = this.request.path();
+        let viewPath;
+        const matchResult = this.matchPathWithRoutes(currentRoute, currentPath);
+        let action = this.params.action ? inflection.camelize(this.params.action.replaceAll("-", "_"), true) : undefined;
+        let controller = this.params.controller;
+        if (!matchResult) {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            controller = "errors";
+            controllerPath = "./built-in/errors/controller.js";
+            action = "notFound";
+            viewPath = await fs.realpath(`${__dirname}/built-in/errors`);
+        }
+        else if (action) {
+            if (!controller)
+                controller = "_root";
+            controllerPath = `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`;
+            viewPath = `${this.configuration.getDirectory()}/src/routes/${controller}`;
+        }
+        else {
+            throw new Error(`Matched the route but didn't know what to do with it: ${currentPath} (action: ${action}, controller: ${controller}, params: ${JSON.stringify(this.params)})`);
+        }
+        const controllerClassImport = await import(controllerPath);
+        const controllerClass = controllerClassImport.default;
+        const controllerInstance = new controllerClass({
+            action,
+            configuration: this.configuration,
+            controller,
+            params: this.params,
+            request: this.request,
+            response: this.response,
+            viewPath
+        });
+        if (!(action in controllerInstance)) {
+            throw new Error(`Missing action on controller: ${controller}#${action}`);
+        }
+        await this.configuration.ensureConnections(async () => {
+            await controllerInstance._runBeforeCallbacks();
+            await controllerInstance[action]();
+        });
+    }
+    /**
+     * @param {import("./base-route.js").default} route
+     * @param {string} path
+     * @returns {{restPath: string} | undefined}
+     */
+    matchPathWithRoutes(route, path) {
+        const pathWithoutSlash = path.replace(/^\//, "");
+        for (const subRoute of route.routes) {
+            const matchResult = subRoute.matchWithPath({
+                params: this.params,
+                path: pathWithoutSlash,
+                request: this.request
+            });
+            if (!matchResult)
+                continue;
+            const { restPath } = matchResult;
+            if (restPath) {
+                return this.matchPathWithRoutes(subRoute, restPath);
+            }
+            return matchResult;
+        }
+    }
+}

package/dist/src/routes/resource-route.d.ts

@@ -0,0 +1,14 @@
+export default VelociousRouteResourceRoute;
+declare class VelociousRouteResourceRoute extends BasicRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }: {
+        name: string;
+    });
+    name: string;
+    regExp: RegExp;
+}
+import BasicRoute from "./basic-route.js";
+//# sourceMappingURL=resource-route.d.ts.map

package/dist/src/routes/resource-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-route.d.ts","sourceRoot":"","sources":["../../../src/routes/resource-route.js"],"names":[],"mappings":";AAOA;IACE;;;OAGG;IACH,mCAFG;QAAqB,IAAI,EAAjB,MAAM;KAChB,EAMA;IAFC,aAAgB;IAChB,eAA+D;CAwClE;uBArDsB,kBAAkB"}

package/dist/src/routes/resource-route.js

@@ -0,0 +1,51 @@
+// @ts-check
+import BaseRoute from "./base-route.js";
+import BasicRoute from "./basic-route.js";
+import escapeStringRegexp from "escape-string-regexp";
+import restArgsError from "../utils/rest-args-error.js";
+class VelociousRouteResourceRoute extends BasicRoute {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     */
+    constructor({ name, ...restArgs }) {
+        super();
+        restArgsError(restArgs);
+        this.name = name;
+        this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`);
+    }
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.params
+     * @param {string} args.path
+     * @param {import("../http-server/client/request.js").default} args.request
+     * @returns {{restPath: string} | undefined}
+     */
+    matchWithPath({ params, path, request }) {
+        const match = path.match(this.regExp);
+        if (match) {
+            const [_beginnigSlash, _matchedName, restPath] = match; // eslint-disable-line no-unused-vars
+            let action = "index";
+            let subRoutesMatchesRestPath = false;
+            for (const route of this.routes) {
+                if (route.matchWithPath({ params, path: restPath, request })) {
+                    subRoutesMatchesRestPath = true;
+                }
+            }
+            if (!subRoutesMatchesRestPath) {
+                if (request.httpMethod() == "POST") {
+                    action = "create";
+                }
+                else if (restPath.match(/\/(.+)/)) {
+                    // TODO: This should change the action to "show" and set the "resource_name_id" in params.
+                    action = "show";
+                }
+            }
+            params.action = action;
+            params.controller = this.name;
+            return { restPath };
+        }
+    }
+}
+BaseRoute.registerRouteResourceType(VelociousRouteResourceRoute);
+export default VelociousRouteResourceRoute;

package/dist/src/routes/root-route.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousRootRoute extends BasicRoute {
+}
+import BasicRoute from "./basic-route.js";
+//# sourceMappingURL=root-route.d.ts.map

package/dist/src/routes/root-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-route.d.ts","sourceRoot":"","sources":["../../../src/routes/root-route.js"],"names":[],"mappings":"AAIA;CACC;uBAHsB,kBAAkB"}

package/dist/src/routes/root-route.js

@@ -0,0 +1,4 @@
+// @ts-check
+import BasicRoute from "./basic-route.js";
+export default class VelociousRootRoute extends BasicRoute {
+}

package/dist/src/testing/request-client.d.ts

@@ -0,0 +1,35 @@
+export default class RequestClient {
+    host: string;
+    port: number;
+    /**
+     * @param {string} path
+     * @returns {Promise<Response>}
+     */
+    get(path: string): Promise<Response>;
+    /**
+     * @param {string} path
+     * @param {object} data
+     * @returns {Promise<Response>}
+     */
+    post(path: string, data: object): Promise<Response>;
+}
+declare class Response {
+    /**
+     * @param {globalThis.Response} fetchResponse
+     */
+    constructor(fetchResponse: globalThis.Response);
+    fetchResponse: globalThis.Response;
+    /**
+     * @returns {Promise<void>}
+     */
+    parse(): Promise<void>;
+    _body: string;
+    /** @returns {string} */
+    body(): string;
+    /** @returns {string | null} */
+    contentType(): string | null;
+    /** @returns {number} */
+    statusCode(): number;
+}
+export {};
+//# sourceMappingURL=request-client.d.ts.map

package/dist/src/testing/request-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-client.d.ts","sourceRoot":"","sources":["../../../src/testing/request-client.js"],"names":[],"mappings":"AAmCA;IACE,aAAkB;IAClB,aAAY;IAEZ;;;OAGG;IACH,UAHW,MAAM,GACJ,OAAO,CAAC,QAAQ,CAAC,CAS7B;IAED;;;;OAIG;IACH,WAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAAC,QAAQ,CAAC,CAoB7B;CACF;AA1ED;IACE;;OAEG;IACH,2BAFW,UAAU,CAAC,QAAQ,EAI7B;IADC,mCAAkC;IAGpC;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;IAHC,cAA4C;IAK9C,wBAAwB;IACxB,QADc,MAAM,CAKnB;IAED,+BAA+B;IAC/B,eADc,MAAM,GAAG,IAAI,CAG1B;IAED,wBAAwB;IACxB,cADc,MAAM,CAC6B;CAClD"}

package/dist/src/testing/request-client.js

@@ -0,0 +1,61 @@
+// @ts-check
+class Response {
+    /**
+     * @param {globalThis.Response} fetchResponse
+     */
+    constructor(fetchResponse) {
+        this.fetchResponse = fetchResponse;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async parse() {
+        this._body = await this.fetchResponse.text();
+        if (this.statusCode() != 200)
+            throw new Error(`Request failed with code ${this.statusCode()} and body: ${this.body()}`);
+    }
+    /** @returns {string} */
+    body() {
+        if (!this._body)
+            throw new Error("Response body not parsed yet. Call parse() first.");
+        return this._body;
+    }
+    /** @returns {string | null} */
+    contentType() {
+        return this.fetchResponse.headers.get("content-type");
+    }
+    /** @returns {number} */
+    statusCode() { return this.fetchResponse.status; }
+}
+export default class RequestClient {
+    host = "localhost";
+    port = 31006;
+    /**
+     * @param {string} path
+     * @returns {Promise<Response>}
+     */
+    async get(path) {
+        const fetchResponse = await fetch(`http://${this.host}:${this.port}${path}`);
+        const response = new Response(fetchResponse);
+        await response.parse();
+        return response;
+    }
+    /**
+     * @param {string} path
+     * @param {object} data
+     * @returns {Promise<Response>}
+     */
+    async post(path, data) {
+        const fetchResponse = await fetch(`http://${this.host}:${this.port}${path}`, {
+            body: JSON.stringify(data),
+            headers: {
+                "Content-Type": "application/json"
+            },
+            method: "POST",
+            signal: AbortSignal.timeout(5000)
+        });
+        const response = new Response(fetchResponse);
+        await response.parse();
+        return response;
+    }
+}

package/dist/src/testing/test-files-finder.d.ts

@@ -0,0 +1,64 @@
+export default class TestFilesFinder {
+    static IGNORED_NAMES: string[];
+    /**
+     * @param {object} args
+     * @param {string} args.directory
+     * @param {string[]} [args.directories]
+     * @param {string[]} args.processArgs
+     */
+    constructor({ directory, directories, processArgs, ...restArgs }: {
+        directory: string;
+        directories?: string[];
+        processArgs: string[];
+    });
+    directory: string;
+    logger: Logger;
+    directories: string[];
+    findingCount: number;
+    processArgs: string[];
+    /** @type {string[]} */
+    foundFiles: string[];
+    /** @type {Record<number, Promise<void>>} */
+    findingPromises: Record<number, Promise<void>>;
+    /** @type {string[]} */
+    testArgs: string[];
+    /** @type {string[]} */
+    directoryArgs: string[];
+    /** @type {string[]} */
+    fileArgs: string[];
+    /**
+     * @returns {Promise<string[]>}
+     */
+    findTestFiles(): Promise<string[]>;
+    /**
+     * @returns {number}
+     */
+    findingPromisesLength(): number;
+    waitForFindingPromises(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    waitForFindingPromisesIteration(): Promise<void>;
+    /**
+     * @param {function() : Promise<void>} callback
+     */
+    withFindingCount(callback: () => Promise<void>): Promise<any>;
+    /**
+     * @param {string} dir
+     * @returns {Promise<void>}
+     */
+    findTestFilesInDir(dir: string): Promise<void>;
+    /**
+     * @param {string} file
+     * @param {string} localPath
+     * @returns {boolean}
+     */
+    isFileMatchingRequirements(file: string, localPath: string): boolean;
+    /**
+     * @param {string} file
+     * @returns {boolean}
+     */
+    looksLikeTestFile(file: string): boolean;
+}
+import { Logger } from "../logger.js";
+//# sourceMappingURL=test-files-finder.d.ts.map

package/dist/src/testing/test-files-finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-files-finder.d.ts","sourceRoot":"","sources":["../../../src/testing/test-files-finder.js"],"names":[],"mappings":"AASA;IACE,+BAA+C;IAE/C;;;;;OAKG;IACH,kEAJG;QAAqB,SAAS,EAAtB,MAAM;QACU,WAAW,GAA3B,MAAM,EAAE;QACO,WAAW,EAA1B,MAAM,EAAE;KAClB,EA0CA;IAtCC,kBAA0B;IAC1B,eAA8B;IAG5B,sBAA8B;IAShC,qBAAqB;IACrB,sBAA8B;IAE9B,uBAAuB;IACvB,YADW,MAAM,EAAE,CACC;IAEpB,4CAA4C;IAC5C,iBADW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CACf;IAEzB,uBAAuB;IACvB,UADW,MAAM,EAAE,CACuD;IAE1E,uBAAuB;IACvB,eADW,MAAM,EAAE,CACI;IAEvB,uBAAuB;IACvB,UADW,MAAM,EAAE,CACD;IAWpB;;OAEG;IACH,iBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAc7B;IAED;;OAEG;IACH,yBAFa,MAAM,CAEwD;IAE3E,wCAIC;IAED;;OAEG;IACH,mCAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;OAEG;IACH,2BAFW,MAAa,OAAO,CAAC,IAAI,CAAC,gBAgBpC;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;OAIG;IACH,iCAJW,MAAM,aACN,MAAM,GACJ,OAAO,CA2BnB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAInB;CACF;uBAzLoB,cAAc"}

package/dist/src/testing/test-files-finder.js

@@ -0,0 +1,159 @@
+// @ts-check
+import fs from "fs/promises";
+import fileExists from "../utils/file-exists.js";
+import { Logger } from "../logger.js";
+import restArgsError from "../utils/rest-args-error.js";
+// Incredibly complex class to find files in multiple simultanious running promises to do it as fast as possible.
+export default class TestFilesFinder {
+    static IGNORED_NAMES = [".git", "node_modules"];
+    /**
+     * @param {object} args
+     * @param {string} args.directory
+     * @param {string[]} [args.directories]
+     * @param {string[]} args.processArgs
+     */
+    constructor({ directory, directories, processArgs, ...restArgs }) {
+        restArgsError(restArgs);
+        this.directory = directory;
+        this.logger = new Logger(this);
+        if (directories) {
+            this.directories = directories;
+        }
+        else {
+            this.directories = [
+                `${this.directory}/__tests__`,
+                `${this.directory}/tests`,
+                `${this.directory}/spec`
+            ];
+        }
+        this.findingCount = 0;
+        this.processArgs = processArgs;
+        /** @type {string[]} */
+        this.foundFiles = [];
+        /** @type {Record<number, Promise<void>>} */
+        this.findingPromises = {};
+        /** @type {string[]} */
+        this.testArgs = this.processArgs.filter((processArg, index) => index != 0);
+        /** @type {string[]} */
+        this.directoryArgs = [];
+        /** @type {string[]} */
+        this.fileArgs = [];
+        for (const testArg of this.testArgs) {
+            if (testArg.endsWith("/")) {
+                this.directoryArgs.push(testArg);
+            }
+            else {
+                this.fileArgs.push(testArg);
+            }
+        }
+    }
+    /**
+     * @returns {Promise<string[]>}
+     */
+    async findTestFiles() {
+        await this.withFindingCount(async () => {
+            for (const directory of this.directories) {
+                if (await fileExists(directory)) {
+                    await this.findTestFilesInDir(directory);
+                }
+            }
+        });
+        await this.waitForFindingPromises();
+        return this.foundFiles;
+    }
+    /**
+     * @returns {number}
+     */
+    findingPromisesLength() { return Object.keys(this.findingPromises).length; }
+    async waitForFindingPromises() {
+        while (this.findingPromisesLength() > 0) {
+            await this.waitForFindingPromisesIteration();
+        }
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async waitForFindingPromisesIteration() {
+        const unfinishedPromises = [];
+        for (const findingPromiseId in this.findingPromises) {
+            const findingPromise = this.findingPromises[findingPromiseId];
+            unfinishedPromises.push(findingPromise);
+        }
+        await Promise.all(unfinishedPromises);
+    }
+    /**
+     * @param {function() : Promise<void>} callback
+     */
+    withFindingCount(callback) {
+        return new Promise((resolve) => {
+            const findingPromise = callback();
+            const findingCount = this.findingCount;
+            this.findingCount += 1;
+            this.findingPromises[findingCount] = findingPromise;
+            findingPromise.finally(() => {
+                delete this.findingPromises[findingCount];
+                resolve(undefined);
+            });
+        });
+    }
+    /**
+     * @param {string} dir
+     * @returns {Promise<void>}
+     */
+    async findTestFilesInDir(dir) {
+        await this.withFindingCount(async () => {
+            const files = await fs.readdir(dir);
+            for (const file of files) {
+                if (TestFilesFinder.IGNORED_NAMES.includes(file)) {
+                    continue;
+                }
+                const fullPath = `${dir}/${file}`;
+                const localPath = fullPath.replace(`${this.directory}/`, "");
+                const isDir = (await fs.stat(fullPath)).isDirectory();
+                if (isDir) {
+                    this.findTestFilesInDir(fullPath);
+                }
+                else {
+                    if (this.isFileMatchingRequirements(file, localPath)) {
+                        this.foundFiles.push(fullPath);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * @param {string} file
+     * @param {string} localPath
+     * @returns {boolean}
+     */
+    isFileMatchingRequirements(file, localPath) {
+        if (this.directoryArgs.length > 0) {
+            for (const directoryArg of this.directoryArgs) {
+                if (localPath.startsWith(directoryArg) && this.looksLikeTestFile(file)) {
+                    this.logger.debug("Found test file because matching dir and looks like this file:", file);
+                    return true;
+                }
+            }
+        }
+        if (this.fileArgs.length > 0) {
+            for (const fileArg of this.fileArgs) {
+                if (fileArg == localPath) {
+                    this.logger.debug("Found test file because matching file arg:", file);
+                    return true;
+                }
+            }
+        }
+        if (this.fileArgs.length == 0 && this.directoryArgs.length == 0 && this.looksLikeTestFile(file)) {
+            this.logger.debug("Found test file because looks like this file:", file);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @param {string} file
+     * @returns {boolean}
+     */
+    looksLikeTestFile(file) {
+        return Boolean(file.match(/-(spec|test)\.(m|)js$/));
+    }
+}

package/dist/src/testing/test-runner.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @typedef {object} TestArgs
+ * @property {Application} [application]
+ * @property {RequestClient} [client]
+ * @property {object} [databaseCleaning]
+ * @property {boolean} [databaseCleaning.transaction]
+ * @property {boolean} [databaseCleaning.truncate]
+ * @property {boolean} [focus]
+ * @property {() => Promise<void>} [function]
+ * @property {string} [type]
+ */
+/**
+ * @typedef {object} TestData
+ * @property {TestArgs} args
+ * @property {function(TestArgs) : Promise<void>} function
+ */
+/**
+ * @typedef {function({configuration: import("../configuration.js").default, testArgs: TestArgs, testData: TestData}) : Promise<void>} AfterBeforeEachCallbackType
+ */
+/**
+ * @typedef {object} AfterBeforeEachCallbackObjectType
+ * @property {AfterBeforeEachCallbackType} callback
+ */
+/**
+ * @typedef {object} TestsArgument
+ * @property {Record<string, TestData>} args
+ * @property {boolean} [anyTestsFocussed]
+ * @property {AfterBeforeEachCallbackObjectType[]} afterEaches
+ * @property {AfterBeforeEachCallbackObjectType[]} beforeEaches
+ * @property {Record<string, TestData>} tests - A unique identifier for the node.
+ * @property {Record<string, TestsArgument>} subs - Optional child nodes. Each item is another `Node`, allowing recursion.
+ */
+export default class TestRunner {
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {Array<string>} args.testFiles
+     */
+    constructor({ configuration, testFiles, ...restArgs }: {
+        configuration: import("../configuration.js").default;
+        testFiles: Array<string>;
+    });
+    _configuration: import("../configuration.js").default;
+    _testFiles: string[];
+    _failedTests: number;
+    _successfulTests: number;
+    _testsCount: number;
+    /**
+     * @returns {import("../configuration.js").default}
+     */
+    getConfiguration(): import("../configuration.js").default;
+    /**
+     * @returns {string[]}
+     */
+    getTestFiles(): string[];
+    /**
+     * @returns {Promise<Application>}
+     */
+    application(): Promise<Application>;
+    _application: Application;
+    /**
+     * @returns {Promise<RequestClient>}
+     */
+    requestClient(): Promise<RequestClient>;
+    _requestClient: RequestClient;
+    /**
+     * @returns {Promise<void>}
+     */
+    importTestFiles(): Promise<void>;
+    /**
+     * @returns {boolean}
+     */
+    isFailed(): boolean;
+    /**
+     * @returns {number}
+     */
+    getFailedTests(): number;
+    /**
+     * @returns {number}
+     */
+    getSuccessfulTests(): number;
+    /**
+     * @returns {number}
+     */
+    getTestsCount(): number;
+    /**
+     * @returns {Promise<void>}
+     */
+    prepare(): Promise<void>;
+    anyTestsFocussed: boolean;
+    _onlyFocussed: boolean;
+    /**
+     * @returns {boolean}
+     */
+    areAnyTestsFocussed(): boolean;
+    /**
+     * @returns {Promise<void>}
+     */
+    run(): Promise<void>;
+    /**
+     * @param {TestsArgument} tests
+     * @returns {{anyTestsFocussed: boolean}}
+     */
+    analyzeTests(tests: TestsArgument): {
+        anyTestsFocussed: boolean;
+    };
+    /**
+     * @param {object} args
+     * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches
+     * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches
+     * @param {TestsArgument} args.tests
+     * @param {string[]} args.descriptions
+     * @param {number} args.indentLevel
+     * @returns {Promise<void>}
+     */
+    runTests({ afterEaches, beforeEaches, tests, descriptions, indentLevel }: {
+        afterEaches: Array<AfterBeforeEachCallbackObjectType>;
+        beforeEaches: Array<AfterBeforeEachCallbackObjectType>;
+        tests: TestsArgument;
+        descriptions: string[];
+        indentLevel: number;
+    }): Promise<void>;
+}
+export type TestArgs = {
+    application?: Application;
+    client?: RequestClient;
+    databaseCleaning?: {
+        transaction?: boolean;
+        truncate?: boolean;
+    };
+    focus?: boolean;
+    function?: () => Promise<void>;
+    type?: string;
+};
+export type TestData = {
+    args: TestArgs;
+    function: (arg0: TestArgs) => Promise<void>;
+};
+export type AfterBeforeEachCallbackType = (arg0: {
+    configuration: import("../configuration.js").default;
+    testArgs: TestArgs;
+    testData: TestData;
+}) => Promise<void>;
+export type AfterBeforeEachCallbackObjectType = {
+    callback: AfterBeforeEachCallbackType;
+};
+export type TestsArgument = {
+    args: Record<string, TestData>;
+    anyTestsFocussed?: boolean;
+    afterEaches: AfterBeforeEachCallbackObjectType[];
+    beforeEaches: AfterBeforeEachCallbackObjectType[];
+    /**
+     * - A unique identifier for the node.
+     */
+    tests: Record<string, TestData>;
+    /**
+     * - Optional child nodes. Each item is another `Node`, allowing recursion.
+     */
+    subs: Record<string, TestsArgument>;
+};
+import Application from "../../src/application.js";
+import RequestClient from "./request-client.js";
+//# sourceMappingURL=test-runner.d.ts.map

package/dist/src/testing/test-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner.d.ts","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AAEH;IACE;;;;OAIG;IACH,uDAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACjB,SAAS,EAA7B,KAAK,CAAC,MAAM,CAAC;KACvB,EAYA;IANC,sDAAmC;IACnC,qBAA2B;IAE3B,qBAAqB;IACrB,yBAAyB;IACzB,oBAAoB;IAGtB;;OAEG;IACH,oBAFa,OAAO,qBAAqB,EAAE,OAAO,CAED;IAEjD;;OAEG;IACH,gBAFa,MAAM,EAAE,CAEoB;IAEzC;;OAEG;IACH,eAFa,OAAO,CAAC,WAAW,CAAC,CAehC;IAXG,0BAIE;IASN;;OAEG;IACH,iBAFa,OAAO,CAAC,aAAa,CAAC,CAQlC;IAJG,8BAAyC;IAM7C;;OAEG;IACH,mBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;OAEG;IACH,YAFa,OAAO,CAE0D;IAE9E;;OAEG;IACH,kBAFa,MAAM,CAMlB;IAED;;OAEG;IACH,sBAFa,MAAM,CAMlB;IAED;;OAEG;IACH,iBAFa,MAAM,CAMlB;IAED;;OAEG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAbC,0BAA6B;IAM7B,uBAA0C;IAS5C;;OAEG;IACH,uBAFa,OAAO,CAQnB;IAED;;OAEG;IACH,OAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;OAGG;IACH,oBAHW,aAAa,GACX;QAAC,gBAAgB,EAAE,OAAO,CAAA;KAAC,CA6BvC;IAED;;;;;;;;OAQG;IACH,0EAPG;QAAuD,WAAW,EAA1D,KAAK,CAAC,iCAAiC,CAAC;QACO,YAAY,EAA3D,KAAK,CAAC,iCAAiC,CAAC;QACpB,KAAK,EAAzB,aAAa;QACE,YAAY,EAA3B,MAAM,EAAE;QACK,WAAW,EAAxB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAuEzB;CACF;;kBAjSa,WAAW;aACX,aAAa;uBAExB;QAAsC,WAAW,GAAtC,OAAO;QACoB,QAAQ,GAAnC,OAAO;KAClB;YAAW,OAAO;eACP,MAAM,OAAO,CAAC,IAAI,CAAC;WACnB,MAAM;;;UAKN,QAAQ;cACR,CAAS,IAAQ,EAAR,QAAQ,KAAI,OAAO,CAAC,IAAI,CAAC;;0CAInC,CAAS,IAA8F,EAA9F;IAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAC,KAAI,OAAO,CAAC,IAAI,CAAC;;cAKvH,2BAA2B;;;UAK3B,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;uBACxB,OAAO;iBACP,iCAAiC,EAAE;kBACnC,iCAAiC,EAAE;;;;WACnC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;;;;UACxB,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;;wBAxCnB,0BAA0B;0BAExB,qBAAqB"}