velocious 1.0.108 → 1.0.109

package/dist/src/testing/test.js

@@ -0,0 +1,408 @@
+// @ts-check
+import { anythingDifferent } from "set-state-compare/src/diff-utils.js";
+import restArgsError from "../utils/rest-args-error.js";
+/** @type {import("./test-runner.js").TestsArgument} */
+const tests = {
+    /** @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
+    afterEaches: [],
+    args: {},
+    /** @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
+    beforeEaches: [],
+    subs: {},
+    tests: {}
+};
+let currentPath = [tests];
+/**
+ * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback
+ * @returns {void}
+ */
+function beforeEach(callback) {
+    const currentTest = currentPath[currentPath.length - 1];
+    currentTest.beforeEaches.push({ callback });
+}
+/**
+ * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback
+ * @returns {void}
+ */
+function afterEach(callback) {
+    const currentTest = currentPath[currentPath.length - 1];
+    currentTest.afterEaches.push({ callback });
+}
+class BaseExpect {
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    async runBefore() { }
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    async runAfter() { }
+}
+class ExpectToChange extends BaseExpect {
+    /**
+     * @param {object} args
+     * @param {function(): Promise<number>} args.changeCallback
+     * @param {Expect} args.expect
+     */
+    constructor({ changeCallback, expect, ...restArgs }) {
+        super();
+        restArgsError(restArgs);
+        this.expect = expect;
+        this.changeCallback = changeCallback;
+    }
+    /**
+     * @param {number} count
+     * @returns {Expect}
+     */
+    by(count) {
+        this.count = count;
+        return this.expect;
+    }
+    async runBefore() {
+        this.oldCount = await this.changeCallback();
+    }
+    async runAfter() {
+        this.newCount = await this.changeCallback();
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async execute() {
+        if (this.newCount === undefined || this.oldCount === undefined) {
+            throw new Error("ExpectToChange not executed properly");
+        }
+        const difference = this.newCount - this.oldCount;
+        if (difference != this.count) {
+            throw new Error(`Expected to change by ${this.count} but changed by ${difference}`);
+        }
+    }
+}
+class Expect extends BaseExpect {
+    /**
+     * @param {any} object
+     */
+    constructor(object) {
+        super();
+        this._object = object;
+        /** @type {Array<Expect | ExpectToChange>} */
+        this.expectations = [];
+    }
+    /**
+     * @param {function(): Promise<number>} changeCallback
+     * @returns {ExpectToChange}
+     */
+    andChange(changeCallback) {
+        return this.toChange(changeCallback);
+    }
+    /**
+     * @returns {this}
+     */
+    get not() {
+        this._not = true;
+        return this;
+    }
+    /**
+     * @param {any} result
+     * @returns {void}
+     */
+    toBe(result) {
+        if (this._not) {
+            if (this._object === result) {
+                throw new Error(`${this._object} was unexpected not to be ${result}`);
+            }
+        }
+        else {
+            if (this._object !== result) {
+                throw new Error(`${this._object} wasn't expected be ${result}`);
+            }
+        }
+    }
+    /**
+     * @returns {void}
+     */
+    toBeDefined() {
+        if (this._not) {
+            if (this._object !== undefined) {
+                throw new Error(`${this._object} wasn´t expected to be defined`);
+            }
+        }
+        else {
+            if (this._object === undefined) {
+                throw new Error(`${this._object} wasn't expected be undefined`);
+            }
+        }
+    }
+    /**
+     * @param {Function} klass
+     * @returns {void}
+     */
+    toBeInstanceOf(klass) {
+        if (!(this._object instanceof klass)) {
+            throw new Error(`Expected ${this._object?.constructor?.name || "null"} to be a ${klass.name} but it wasn't`);
+        }
+    }
+    /**
+     * @returns {void}
+     */
+    toBeFalse() {
+        this.toBe(false);
+    }
+    /**
+     * @returns {void}
+     */
+    toBeUndefined() {
+        this.toBe(undefined);
+    }
+    /**
+     * @returns {void}
+     */
+    toBeTrue() {
+        this.toBe(true);
+    }
+    /**
+     * @param {function(): Promise<number>} changeCallback
+     * @returns {ExpectToChange}
+     */
+    toChange(changeCallback) {
+        if (this._not)
+            throw new Error("not stub");
+        const expectToChange = new ExpectToChange({ changeCallback, expect: this });
+        this.expectations.push(expectToChange);
+        return expectToChange;
+    }
+    /**
+     * @param {any} valueToContain
+     * @returns {void}
+     */
+    toContain(valueToContain) {
+        if (this._not)
+            throw new Error("not stub");
+        if (!this._object.includes(valueToContain)) {
+            throw new Error(`${this._object} doesn't contain ${valueToContain}`);
+        }
+    }
+    /**
+     * @param {any} result
+     * @returns {void}
+     */
+    toEqual(result) {
+        if (this._not) {
+            if (typeof this._object == "object" && typeof result == "object") {
+                if (!anythingDifferent(this._object, result)) {
+                    throw new Error(`${this._object} was unexpected equal to ${result}`);
+                }
+            }
+            else {
+                if (this._object == result) {
+                    throw new Error(`${this._object} was unexpected equal to ${result}`);
+                }
+            }
+        }
+        else {
+            if (typeof this._object == "object" && typeof result == "object") {
+                if (anythingDifferent(this._object, result)) {
+                    throw new Error(`${JSON.stringify(this._object)} wasn't equal to ${JSON.stringify(result)}`);
+                }
+            }
+            else {
+                if (this._object != result) {
+                    throw new Error(`${this._object} wasn't equal to ${result}`);
+                }
+            }
+        }
+    }
+    /**
+     * @param {RegExp} regex
+     * @returns {void}
+     */
+    toMatch(regex) {
+        const match = this._object.match(regex);
+        if (this._not) {
+            if (match) {
+                throw new Error(`${this._object} shouldn't match ${regex}`);
+            }
+        }
+        else {
+            if (!match) {
+                throw new Error(`${this._object} didn't match ${regex}`);
+            }
+        }
+    }
+    /**
+     * @template T extends Error
+     * @param {string|T} expectedError
+     * @returns {Promise<void>}
+     */
+    async toThrowError(expectedError) {
+        if (this._not)
+            throw new Error("not stub");
+        let failedError;
+        try {
+            await this._object();
+        }
+        catch (error) {
+            failedError = error;
+        }
+        if (!failedError)
+            throw new Error("Expected to fail but didn't");
+        let expectedErrorMessage, failedErrorMessage;
+        if (typeof failedError == "string") {
+            failedErrorMessage = failedError;
+        }
+        else if (failedError instanceof Error) {
+            failedErrorMessage = failedError.message;
+        }
+        else {
+            failedErrorMessage = String(failedError);
+        }
+        if (typeof expectedError == "string") {
+            expectedErrorMessage = expectedError;
+        }
+        else if (expectedError instanceof Error) {
+            expectedErrorMessage = expectedError.message;
+        }
+        else {
+            expectedErrorMessage = String(expectedError);
+        }
+        if (failedErrorMessage != expectedErrorMessage) {
+            throw new Error(`Expected to fail with '${expectedErrorMessage}' but failed with '${failedErrorMessage}'`);
+        }
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    async execute() {
+        for (const expectation of this.expectations) {
+            await expectation.runBefore();
+        }
+        const result = await this._object();
+        for (const expectation of this.expectations) {
+            await expectation.runAfter();
+        }
+        for (const expectation of this.expectations) {
+            await expectation.execute();
+        }
+        return result;
+    }
+    /**
+     * @param {Record<string, any>} result
+     * @returns {void}
+     */
+    toHaveAttributes(result) {
+        if (this._not)
+            throw new Error("not stub");
+        /** @type {Record<string, any[]>} */
+        const differences = {};
+        for (const key in result) {
+            const value = result[key];
+            if (!(key in this._object))
+                throw new Error(`${this._object.constructor.name} doesn't respond to ${key}`);
+            const objectValue = this._object[key]();
+            if (value != objectValue) {
+                differences[key] = [value, objectValue];
+            }
+        }
+        if (Object.keys(differences).length > 0) {
+            throw new Error(`Object had differet values: ${JSON.stringify(differences)}`);
+        }
+    }
+}
+/**
+ * @param {string} description
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
+ * @returns {Promise<void>}
+ */
+async function describe(description, arg1, arg2) {
+    let testArgs, testFunction;
+    if (typeof arg2 == "function") {
+        testFunction = arg2;
+        testArgs = arg1;
+    }
+    else if (typeof arg1 == "function") {
+        testFunction = arg1;
+        testArgs = {};
+    }
+    else {
+        throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`);
+    }
+    const currentTest = currentPath[currentPath.length - 1];
+    const newTestArgs = Object.assign({}, currentTest.args, testArgs);
+    if (description in currentTest.subs) {
+        throw new Error(`Duplicate test description: ${description}`);
+    }
+    const newTestData = { afterEaches: [], args: newTestArgs, beforeEaches: [], subs: {}, tests: {} };
+    currentTest.subs[description] = newTestData;
+    currentPath.push(newTestData);
+    try {
+        await testFunction();
+    }
+    finally {
+        currentPath.pop();
+    }
+}
+/**
+ * @param {any} arg
+ * @returns {Expect}
+ */
+function expect(arg) {
+    return new Expect(arg);
+}
+/**
+ * @param {string} description
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
+ * @returns {void}
+ */
+function it(description, arg1, arg2) {
+    const currentTest = currentPath[currentPath.length - 1];
+    let testArgs;
+    /** @type {() => Promise<void>} */
+    let testFunction;
+    if (typeof arg1 == "function") {
+        testFunction = arg1;
+        testArgs = {};
+    }
+    else if (typeof arg2 == "function") {
+        testFunction = arg2;
+        testArgs = arg1;
+    }
+    else {
+        throw new Error(`Invalid arguments for it: ${description}, ${arg1}`);
+    }
+    const newTestArgs = Object.assign({}, currentTest.args, testArgs);
+    currentTest.tests[description] = { args: newTestArgs, function: testFunction };
+}
+/**
+ * @param {string} description
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
+ * @returns {void}
+ */
+function fit(description, arg1, arg2) {
+    let testArgs;
+    /** @type {() => Promise<void>} */
+    let testFunction;
+    if (typeof arg1 == "function") {
+        testFunction = arg1;
+        testArgs = { focus: true };
+    }
+    else if (typeof arg2 == "function") {
+        testFunction = arg2;
+        testArgs = Object.assign({ focus: true }, arg1);
+    }
+    else {
+        throw new Error(`Invalid arguments for it: ${description}, ${arg1}`);
+    }
+    return it(description, testArgs, testFunction);
+}
+// Make the methods global so they can be used in test files
+globalThis.afterEach = afterEach;
+globalThis.beforeEach = beforeEach;
+globalThis.describe = describe;
+globalThis.expect = expect;
+globalThis.it = it;
+globalThis.fit = fit;
+export { afterEach, beforeEach, describe, expect, fit, it, tests };

package/dist/src/utils/backtrace-cleaner.d.ts

@@ -0,0 +1,17 @@
+export default class BacktraceCleaner {
+    /**
+     * @param {Error} error
+     * @returns {string | undefined}
+     */
+    static getCleanedStack(error: Error): string | undefined;
+    /**
+     * @param {Error} error
+     */
+    constructor(error: Error);
+    error: Error;
+    /**
+     * @returns {string | undefined}
+     */
+    getCleanedStack(): string | undefined;
+}
+//# sourceMappingURL=backtrace-cleaner.d.ts.map

package/dist/src/utils/backtrace-cleaner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backtrace-cleaner.d.ts","sourceRoot":"","sources":["../../../src/utils/backtrace-cleaner.js"],"names":[],"mappings":"AAEA;IACE;;;OAGG;IACH,8BAHW,KAAK,GACH,MAAM,GAAG,SAAS,CAI9B;IAED;;OAEG;IACH,mBAFW,KAAK,EAIf;IADC,aAAkB;IAGpB;;OAEG;IACH,mBAFa,MAAM,GAAG,SAAS,CAM9B;CACF"}

package/dist/src/utils/backtrace-cleaner.js

@@ -0,0 +1,23 @@
+// @ts-check
+export default class BacktraceCleaner {
+    /**
+     * @param {Error} error
+     * @returns {string | undefined}
+     */
+    static getCleanedStack(error) {
+        return new BacktraceCleaner(error).getCleanedStack();
+    }
+    /**
+     * @param {Error} error
+     */
+    constructor(error) {
+        this.error = error;
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    getCleanedStack() {
+        const backtrace = this.error?.stack?.split("\n");
+        return backtrace?.filter((line) => !line.includes("node_modules") && !line.includes("(node:internal/process/")).join("\n");
+    }
+}

package/dist/src/utils/ensure-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {any} error
+ * @returns {Error}
+ */
+export default function ensureError(error: any): Error;
+//# sourceMappingURL=ensure-error.d.ts.map

package/dist/src/utils/ensure-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-error.d.ts","sourceRoot":"","sources":["../../../src/utils/ensure-error.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,2CAHW,GAAG,GACD,KAAK,CAQjB"}

package/dist/src/utils/ensure-error.js

@@ -0,0 +1,13 @@
+// @ts-check
+/**
+ * @param {any} error
+ * @returns {Error}
+ */
+export default function ensureError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    else {
+        return new Error(`Unknown error type ${typeof error}: ${error}`);
+    }
+}

package/dist/src/utils/file-exists.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {string} path
+ * @returns {Promise<boolean>}
+ */
+export default function fileExists(path: string): Promise<boolean>;
+//# sourceMappingURL=file-exists.d.ts.map

package/dist/src/utils/file-exists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-exists.d.ts","sourceRoot":"","sources":["../../../src/utils/file-exists.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,yCAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAU5B"}

package/dist/src/utils/file-exists.js

@@ -0,0 +1,15 @@
+// @ts-check
+import fs from "fs/promises";
+/**
+ * @param {string} path
+ * @returns {Promise<boolean>}
+ */
+export default async function fileExists(path) {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch (error) { // eslint-disable-line no-unused-vars
+        return false;
+    }
+}

package/dist/src/utils/nest-callbacks.d.ts

@@ -0,0 +1,2 @@
+export default function nestCallbacks(callbacksToNestInside: any, callback: any): Promise<void>;
+//# sourceMappingURL=nest-callbacks.d.ts.map

package/dist/src/utils/nest-callbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nest-callbacks.d.ts","sourceRoot":"","sources":["../../../src/utils/nest-callbacks.js"],"names":[],"mappings":"AAAA,gGAcC"}

package/dist/src/utils/nest-callbacks.js

@@ -0,0 +1,11 @@
+export default async function nestCallbacks(callbacksToNestInside, callback) {
+    let runCallback = callback;
+    for (const callbackToNestInside of callbacksToNestInside) {
+        let actualRunCallback = runCallback;
+        const nextRunRequest = async () => {
+            await callbackToNestInside(actualRunCallback);
+        };
+        runCallback = nextRunRequest;
+    }
+    await runCallback();
+}

package/dist/src/utils/rest-args-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {object} restArgs
+ * @returns {void}
+ */
+export default function restArgsError(restArgs: object): void;
+//# sourceMappingURL=rest-args-error.d.ts.map

package/dist/src/utils/rest-args-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-args-error.d.ts","sourceRoot":"","sources":["../../../src/utils/rest-args-error.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,gDAHW,MAAM,GACJ,IAAI,CAQhB"}

package/dist/src/utils/rest-args-error.js

@@ -0,0 +1,11 @@
+// @ts-check
+/**
+ * @param {object} restArgs
+ * @returns {void}
+ */
+export default function restArgsError(restArgs) {
+    const restArgsKeys = Object.keys(restArgs);
+    if (restArgsKeys.length > 0) {
+        throw new Error(`Unknown arguments: ${restArgsKeys.join(", ")}`);
+    }
+}

package/dist/src/utils/with-tracked-stack-async-hooks.d.ts

@@ -0,0 +1,10 @@
+/** @param {Error} error */
+export function addTrackedStackToError(error: Error): void;
+/**
+ *
+ * @param {() => Promise<void> | string} arg1
+ * @param {() => Promise<void> | Error} [arg2]
+ * @returns {Promise<void>}
+ */
+export function withTrackedStack(arg1: () => Promise<void> | string, arg2?: () => Promise<void> | Error): Promise<void>;
+//# sourceMappingURL=with-tracked-stack-async-hooks.d.ts.map

package/dist/src/utils/with-tracked-stack-async-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-tracked-stack-async-hooks.d.ts","sourceRoot":"","sources":["../../../src/utils/with-tracked-stack-async-hooks.js"],"names":[],"mappings":"AAWA,2BAA2B;AAC3B,8CADY,KAAK,QAgBhB;AAED;;;;;GAKG;AACH,uCAJW,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,SAC5B,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,GACzB,OAAO,CAAC,IAAI,CAAC,CA2CzB"}

package/dist/src/utils/with-tracked-stack-async-hooks.js

@@ -0,0 +1,69 @@
+// @ts-check
+import { AsyncLocalStorage } from "async_hooks";
+/** @type {AsyncLocalStorage<Array<string[]>> | undefined} */
+let asyncLocalStorage;
+if (AsyncLocalStorage) {
+    asyncLocalStorage = new AsyncLocalStorage();
+}
+/** @param {Error} error */
+function addTrackedStackToError(error) {
+    // Not supported
+    if (!asyncLocalStorage)
+        return;
+    const parentStacks = asyncLocalStorage.getStore() || [];
+    const additionalStackLines = [];
+    for (const parentStack of parentStacks) {
+        for (const parentStackLine of parentStack) {
+            additionalStackLines.push(parentStackLine);
+        }
+    }
+    // Replace the error message on the first line with this string
+    error.stack += "\n" + additionalStackLines.join("\n");
+}
+/**
+ *
+ * @param {() => Promise<void> | string} arg1
+ * @param {() => Promise<void> | Error} [arg2]
+ * @returns {Promise<void>}
+ */
+async function withTrackedStack(arg1, arg2) {
+    /** @type {() => Promise<void>} */
+    let callback;
+    /** @type {string} */
+    let stack;
+    if (typeof arg2 == "function" && typeof arg1 == "string") {
+        // @ts-expect-error
+        callback = arg2;
+        stack = arg1;
+    }
+    else {
+        // @ts-expect-error
+        callback = arg1;
+        stack = Error().stack || "";
+    }
+    // Not supported
+    if (!asyncLocalStorage)
+        return await callback();
+    const parentStacks = asyncLocalStorage.getStore() || [];
+    const additionalStackLines = [];
+    const currentStackLines = stack.split("\n");
+    currentStackLines[0] = "    [WITH TRACKED STACK]";
+    for (let i = currentStackLines.length; i >= 0; i--) {
+        const stackLine = currentStackLines[i];
+        additionalStackLines.unshift(stackLine);
+        if (stackLine == "    [WITH TRACKED STACK]") {
+            break;
+        }
+    }
+    const newStacks = [additionalStackLines, ...parentStacks];
+    await asyncLocalStorage.run(newStacks, async () => {
+        await callback();
+    });
+}
+if (globalThis.withTrackedStack) {
+    console.warn("globalThis.withTrackedStack was already defined");
+}
+else {
+    globalThis.withTrackedStack = { addTrackedStackToError, withTrackedStack };
+}
+export { addTrackedStackToError, withTrackedStack };

package/dist/src/utils/with-tracked-stack.d.ts

@@ -0,0 +1,8 @@
+/** @param {Error} error */
+export function addTrackedStackToError(error: Error): void;
+/**
+ * @param  {...any} args
+ * @returns {Promise<any>}
+ */
+export function withTrackedStack(...args: any[]): Promise<any>;
+//# sourceMappingURL=with-tracked-stack.d.ts.map

package/dist/src/utils/with-tracked-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-tracked-stack.d.ts","sourceRoot":"","sources":["../../../src/utils/with-tracked-stack.js"],"names":[],"mappings":"AAEA,2BAA2B;AAC3B,8CADY,KAAK,QAGhB;AAED;;;GAGG;AACH,0CAHe,GAAG,EAAA,GACL,OAAO,CAAC,GAAG,CAAC,CAkBxB"}

package/dist/src/utils/with-tracked-stack.js

@@ -0,0 +1,26 @@
+// @ts-check
+/** @param {Error} error */
+function addTrackedStackToError(error) {
+    globalThis.withTrackedStack?.addTrackedStackToError(error);
+}
+/**
+ * @param  {...any} args
+ * @returns {Promise<any>}
+ */
+async function withTrackedStack(...args) {
+    const withTrackedStack = globalThis.withTrackedStack?.withTrackedStack;
+    let callback;
+    if (args[1]) {
+        callback = args[1];
+    }
+    else {
+        callback = args[0];
+    }
+    if (withTrackedStack) {
+        return await withTrackedStack(...args);
+    }
+    else {
+        return await callback();
+    }
+}
+export { addTrackedStackToError, withTrackedStack };