@rspack-debug/test-tools 1.3.14

package/dist/helper/legacy/createLazyTestEnv.js

@@ -0,0 +1,116 @@
+"use strict";
+// @ts-nocheck
+module.exports = (globalTimeout = 2000, nameSuffix = "") => {
+    const state = global.JEST_STATE_SYMBOL;
+    let currentDescribeBlock;
+    let currentlyRunningTest;
+    let runTests = -1;
+    const disposables = [];
+    // this function allows to release memory in fn context
+    // manually, usually after the suite has been run.
+    const createDisposableFn = (fn, isTest) => {
+        if (!fn)
+            return null;
+        let rfn;
+        if (fn.length >= 1) {
+            rfn = done => {
+                fn((...args) => {
+                    if (isTest)
+                        runTests++;
+                    done(...args);
+                });
+            };
+        }
+        else {
+            rfn = () => {
+                const r = fn();
+                if (isTest)
+                    runTests++;
+                return r;
+            };
+        }
+        disposables.push(() => {
+            fn = null;
+        });
+        return rfn;
+    };
+    describe(nameSuffix ? `exported tests ${nameSuffix}` : "exported tests", () => {
+        // this must have a child to be handled correctly
+        it("should run the exported tests", () => {
+            runTests++;
+        });
+        afterAll(done => {
+            for (const dispose of disposables) {
+                dispose();
+            }
+            done();
+        });
+        currentDescribeBlock = state.currentDescribeBlock;
+        currentlyRunningTest = state.currentlyRunningTest;
+    });
+    let numberOfTests = 0;
+    const inSuite = fn => {
+        const { currentDescribeBlock: oldCurrentDescribeBlock, currentlyRunningTest: oldCurrentlyRunningTest, hasStarted: oldHasStarted } = state;
+        state.currentDescribeBlock = currentDescribeBlock;
+        state.currentlyRunningTest = currentlyRunningTest;
+        state.hasStarted = false;
+        try {
+            fn();
+        }
+        catch (e) {
+            // avoid leaking memory
+            e.stack;
+            throw e;
+        }
+        state.currentDescribeBlock = oldCurrentDescribeBlock;
+        state.currentlyRunningTest = oldCurrentlyRunningTest;
+        state.hasStarted = oldHasStarted;
+    };
+    const fixAsyncError = block => {
+        // By default jest leaks memory as it stores asyncError
+        // for each "it" call to track the origin test suite
+        // We want to evaluate this early here to avoid leaking memory
+        block.asyncError = {
+            stack: block.asyncError.stack
+        };
+    };
+    return {
+        setDefaultTimeout(time) {
+            globalTimeout = time;
+        },
+        getNumberOfTests() {
+            return numberOfTests;
+        },
+        it(...args) {
+            numberOfTests++;
+            if (runTests >= numberOfTests)
+                throw new Error("it called too late");
+            args[1] = createDisposableFn(args[1], true);
+            args[2] = args[2] || globalTimeout;
+            inSuite(() => {
+                it(...args);
+                fixAsyncError(currentDescribeBlock.tests[currentDescribeBlock.tests.length - 1]);
+            });
+        },
+        beforeEach(...args) {
+            if (runTests >= numberOfTests)
+                throw new Error("beforeEach called too late");
+            args[0] = createDisposableFn(args[0]);
+            inSuite(() => {
+                beforeEach(...args);
+                fixAsyncError(currentDescribeBlock.hooks[currentDescribeBlock.hooks.length - 1]);
+            });
+        },
+        afterEach(...args) {
+            if (runTests >= numberOfTests)
+                throw new Error("afterEach called too late");
+            args[0] = createDisposableFn(args[0]);
+            inSuite(() => {
+                afterEach(...args);
+                fixAsyncError(currentDescribeBlock.hooks[currentDescribeBlock.hooks.length - 1]);
+            });
+        },
+        expect,
+        jest
+    };
+};

package/dist/helper/legacy/createLogger.d.ts

@@ -0,0 +1,23 @@
+declare function _exports(appendTarget: any): {
+    log: (l: any) => any;
+    debug: (l: any) => any;
+    trace: (l: any) => any;
+    info: (l: any) => any;
+    warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    error: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    logTime: () => void;
+    group: () => void;
+    groupCollapsed: () => void;
+    groupEnd: () => void;
+    profile: () => void;
+    profileEnd: () => void;
+    clear: () => void;
+    status: () => void;
+};
+export = _exports;

package/dist/helper/legacy/createLogger.js

@@ -0,0 +1,20 @@
+"use strict";
+// @ts-nocheck
+module.exports = appendTarget => {
+    return {
+        log: l => appendTarget.push(l),
+        debug: l => appendTarget.push(l),
+        trace: l => appendTarget.push(l),
+        info: l => appendTarget.push(l),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        logTime: () => { },
+        group: () => { },
+        groupCollapsed: () => { },
+        groupEnd: () => { },
+        profile: () => { },
+        profileEnd: () => { },
+        clear: () => { },
+        status: () => { }
+    };
+};

package/dist/helper/legacy/currentScript.d.ts

@@ -0,0 +1,6 @@
+export = CurrentScript;
+declare class CurrentScript {
+    constructor(path?: string, type?: string);
+    src: string;
+    type: string;
+}

package/dist/helper/legacy/currentScript.js

@@ -0,0 +1,8 @@
+"use strict";
+class CurrentScript {
+    constructor(path = "", type = "text/javascript") {
+        this.src = `https://test.cases/path/${path}index.js`;
+        this.type = type;
+    }
+}
+module.exports = CurrentScript;

package/dist/helper/legacy/fakeSystem.d.ts

@@ -0,0 +1,9 @@
+export function register(name: any, deps: any, fn: any): void;
+export function set(name: any, exports: any): void;
+export let registry: undefined;
+export let _require: undefined;
+export let _nextName: string;
+export function setRequire(req: any): void;
+export function init(modules: any): void;
+export function execute(name: any): any;
+export function ensureExecuted(name: any): any;

package/dist/helper/legacy/fakeSystem.js

@@ -0,0 +1,124 @@
+"use strict";
+// @ts-nocheck
+const System = {
+    register: (name, deps, fn) => {
+        if (!System.registry) {
+            throw new Error("System is no initialized");
+        }
+        if (typeof name !== "string") {
+            fn = deps;
+            deps = name;
+            name = System._nextName;
+        }
+        if (!Array.isArray(deps)) {
+            fn = deps;
+            deps = [];
+        }
+        const dynamicExport = result => {
+            if (System.registry[name] !== entry) {
+                throw new Error(`Module ${name} calls dynamicExport too late`);
+            }
+            entry.exports = result;
+            for (const mod of Object.keys(System.registry)) {
+                const m = System.registry[mod];
+                if (!m.deps)
+                    continue;
+                for (let i = 0; i < m.deps.length; i++) {
+                    const dep = m.deps[i];
+                    if (dep !== name)
+                        continue;
+                    const setters = m.mod.setters[i];
+                    setters(result);
+                }
+            }
+        };
+        const systemContext = {
+            meta: {
+                url: `/${name}.js`
+            },
+            import() {
+                return Promise.resolve();
+            }
+        };
+        if (name in System.registry) {
+            throw new Error(`Module ${name} is already registered`);
+        }
+        const mod = fn(dynamicExport, systemContext);
+        if (deps.length > 0) {
+            if (!Array.isArray(mod.setters)) {
+                throw new Error(`Module ${name} must have setters, because it has dependencies`);
+            }
+            if (mod.setters.length !== deps.length) {
+                throw new Error(`Module ${name} has incorrect number of setters for the dependencies`);
+            }
+        }
+        const entry = {
+            name,
+            deps,
+            fn,
+            mod,
+            executed: false,
+            exports: undefined
+        };
+        System.registry[name] = entry;
+    },
+    set: (name, exports) => {
+        System.registry[name] = {
+            name,
+            executed: true,
+            exports
+        };
+    },
+    registry: undefined,
+    _require: undefined,
+    _nextName: "(anonym)",
+    setRequire: req => {
+        System._require = req;
+    },
+    init: modules => {
+        System.registry = {};
+        if (modules) {
+            for (const name of Object.keys(modules)) {
+                System.registry[name] = {
+                    executed: true,
+                    exports: modules[name]
+                };
+            }
+        }
+    },
+    execute: name => {
+        const m = System.registry[name];
+        if (!m)
+            throw new Error(`Module ${name} not registered`);
+        if (m.executed)
+            throw new Error(`Module ${name} was already executed`);
+        return System.ensureExecuted(name);
+    },
+    ensureExecuted: name => {
+        let m = System.registry[name];
+        if (!m && System._require) {
+            const oldName = System._nextName;
+            System._nextName = name;
+            System._require(name);
+            System._nextName = oldName;
+            m = System.registry[name];
+        }
+        if (!m) {
+            throw new Error(`Module ${name} not registered`);
+        }
+        if (!m.executed) {
+            m.executed = true;
+            for (let i = 0; i < m.deps.length; i++) {
+                const dep = m.deps[i];
+                const setters = m.mod.setters[i];
+                System.ensureExecuted(dep);
+                const { exports } = System.registry[dep];
+                if (exports !== undefined)
+                    setters(exports);
+            }
+            m.mod.execute();
+        }
+        return m.exports;
+    }
+};
+module.exports = System;

package/dist/helper/legacy/parseResource.d.ts

@@ -0,0 +1,6 @@
+export function parseResource(str: any): {
+    resource: any;
+    path: string;
+    query: string;
+    fragment: string;
+};

package/dist/helper/legacy/parseResource.js

@@ -0,0 +1,15 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseResource = void 0;
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\u200b.|[^?#\u200b])*)(\?(?:\u200b.|[^#\u200b])*)?(#.*)?$/;
+const parseResource = str => {
+    const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+    return {
+        resource: str,
+        path: match[1].replace(/\u200b(.)/g, "$1"),
+        query: match[2] ? match[2].replace(/\u200b(.)/g, "$1") : "",
+        fragment: match[3] || ""
+    };
+};
+exports.parseResource = parseResource;

package/dist/helper/legacy/supportsImportFn.d.ts

@@ -0,0 +1 @@
+export declare function supportsImportFn(): boolean;

package/dist/helper/legacy/supportsImportFn.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsImportFn = supportsImportFn;
+// @ts-nocheck
+const nodeVersion = process.versions.node.split(".").map(Number);
+function supportsImportFn() {
+    // Segmentation fault in vm with --experimental-vm-modules,
+    // which has not been resolved in node 16 yet.
+    // https://github.com/nodejs/node/issues/35889
+    if (nodeVersion[0] > 16) {
+        return true;
+    }
+    return false;
+}
+;

package/dist/helper/legacy/supportsWorker.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsWorker.js

@@ -0,0 +1,17 @@
+"use strict";
+// @ts-nocheck
+const nodeVersion = process.versions.node.split(".").map(Number);
+module.exports = function supportsWorker() {
+    // Verify that in the current node version new Worker() accepts URL as the first parameter:
+    // https://nodejs.org/api/worker_threads.html#worker_threads_new_worker_filename_options
+    if (nodeVersion[0] >= 14) {
+        return true;
+    }
+    if (nodeVersion[0] === 13 && nodeVersion[1] >= 12) {
+        return true;
+    }
+    if (nodeVersion[0] === 12 && nodeVersion[1] >= 17) {
+        return true;
+    }
+    return false;
+};

package/dist/helper/legacy/urlToRelativePath.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(url: any): string;
+export = _exports;

package/dist/helper/legacy/urlToRelativePath.js

@@ -0,0 +1,7 @@
+"use strict";
+// @ts-nocheck
+module.exports = function urlToRelativePath(url) {
+    if (url.startsWith("https://test.cases/path/"))
+        url = url.slice(24);
+    return `./${url}`;
+};

package/dist/helper/legacy/walkCssTokens.d.ts

@@ -0,0 +1,40 @@
+declare namespace _exports {
+    export { CssTokenCallbacks, CharHandler };
+}
+declare function _exports(input: string, callbacks: CssTokenCallbacks): void;
+declare namespace _exports {
+    export { isIdentStartCodePoint };
+    export function eatComments(input: string, pos: number): number;
+    export function eatWhitespace(input: string, pos: number): number;
+    export function eatWhitespaceAndComments(input: string, pos: number): number;
+    export function eatWhiteLine(input: string, pos: number): number;
+}
+export = _exports;
+type CssTokenCallbacks = {
+    isSelector?: ((arg0: string, arg1: number) => boolean) | undefined;
+    url?: ((arg0: string, arg1: number, arg2: number, arg3: number, arg4: number) => number) | undefined;
+    string?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    leftParenthesis?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    rightParenthesis?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    pseudoFunction?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    function?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    pseudoClass?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    atKeyword?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    class?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    identifier?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    id?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    leftCurlyBracket?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    rightCurlyBracket?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    semicolon?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+    comma?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
+};
+type CharHandler = (arg0: string, arg1: number, arg2: CssTokenCallbacks) => number;
+/**
+ * ident-start code point
+ *
+ * A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+ *
+ * @param {number} cc char code
+ * @returns {boolean} true, if cc is a start code point of an identifier
+ */
+declare function isIdentStartCodePoint(cc: number): boolean;