@rspack-debug/test-tools 1.3.14

package/dist/helper/legacy/FakeDocument.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeSheet = exports.FakeElement = void 0;
+// @ts-nocheck
+const fs = require("node:fs");
+const path = require("node:path");
+const getPropertyValue = function (property) {
+    return this[property];
+};
+class FakeDocument {
+    constructor(basePath, options = {}) {
+        this.head = this.createElement("head");
+        this.body = this.createElement("body");
+        this.baseURI = "https://test.cases/path/index.html";
+        this._elementsByTagName = new Map([
+            ["head", [this.head]],
+            ["body", [this.body]]
+        ]);
+        this._basePath = basePath;
+        this.currentScript = undefined;
+        this._options = options || {};
+    }
+    createElement(type) {
+        return new FakeElement(this, type, this._basePath);
+    }
+    _onElementAttached(element) {
+        const type = element._type;
+        let list = this._elementsByTagName.get(type);
+        if (list === undefined) {
+            list = [];
+            this._elementsByTagName.set(type, list);
+        }
+        list.push(element);
+    }
+    _onElementRemoved(element) {
+        const type = element._type;
+        const list = this._elementsByTagName.get(type);
+        const idx = list.indexOf(element);
+        list.splice(idx, 1);
+    }
+    getElementsByTagName(name) {
+        return this._elementsByTagName.get(name) || [];
+    }
+    querySelectorAll(name) {
+        return this._elementsByTagName.get(name) || [];
+    }
+    getComputedStyle(element) {
+        const style = { getPropertyValue };
+        const links = this.getElementsByTagName("link");
+        for (const link of links) {
+            for (const rule of link.sheet.cssRules) {
+                if (rule.selectorText === element._type) {
+                    Object.assign(style, rule.style);
+                }
+            }
+        }
+        return style;
+    }
+}
+exports.default = FakeDocument;
+class FakeElement {
+    constructor(document, type, basePath) {
+        this._document = document;
+        this._type = type;
+        this._basePath = basePath;
+        this._children = [];
+        this._attributes = Object.create(null);
+        this._src = undefined;
+        this._href = undefined;
+        this.rel = undefined;
+        this.parentNode = undefined;
+        this.sheet = type === "link" ? new FakeSheet(this, basePath) : undefined;
+    }
+    cloneNode() {
+        return new FakeElement(this._document, this._type, this._basePath);
+    }
+    addEventListener() { }
+    insertBefore(node, before) {
+        this._document._onElementAttached(node);
+        node.parentNode = this;
+        this._children.unshift(node);
+        Promise.resolve().then(() => {
+            if (node.onload) {
+                node.onload({ type: "load", target: node });
+            }
+        });
+    }
+    appendChild(node) {
+        this._document._onElementAttached(node);
+        this._children.push(node);
+        node.parentNode = this;
+        if (node._type === "link") {
+            setTimeout(() => {
+                if (node.onload)
+                    node.onload({ type: "load", target: node });
+            }, 100);
+        }
+        else if (node._type === "script") {
+            Promise.resolve().then(() => {
+                if (typeof this._document._options.onScript === "function") {
+                    this._document._options.onScript(node);
+                }
+                if (node.onload) {
+                    node.onload({
+                        type: "load",
+                        target: node
+                    });
+                }
+            });
+        }
+        else {
+            if (node.onload) {
+                node.onload({ type: "load", target: node });
+            }
+        }
+    }
+    removeChild(node) {
+        const idx = this._children.indexOf(node);
+        if (idx >= 0) {
+            this._children.splice(idx, 1);
+            this._document._onElementRemoved(node);
+            node.parentNode = undefined;
+        }
+    }
+    setAttribute(name, value) {
+        if (this._type === "link" && name === "href") {
+            this.href(value);
+        }
+        else {
+            this._attributes[name] = value;
+        }
+    }
+    removeAttribute(name) {
+        delete this._attributes[name];
+    }
+    getAttribute(name) {
+        if (this._type === "link" && name === "href") {
+            return this.href;
+        }
+        return this._attributes[name];
+    }
+    _toRealUrl(value) {
+        if (/^\//.test(value)) {
+            return `https://test.cases${value}`;
+        }
+        else if (/^\.\.\//.test(value)) {
+            return `https://test.cases${value.slice(2)}`;
+        }
+        else if (/^\.\//.test(value)) {
+            return `https://test.cases/path${value.slice(1)}`;
+        }
+        else if (/^\w+:\/\//.test(value)) {
+            return value;
+        }
+        else if (/^\/\//.test(value)) {
+            return `https:${value}`;
+        }
+        else {
+            return `https://test.cases/path/${value}`;
+        }
+    }
+    set src(value) {
+        if (this._type === "script") {
+            this._src = this._toRealUrl(value);
+        }
+    }
+    get children() {
+        return this._children;
+    }
+    get src() {
+        return this._src;
+    }
+    set href(value) {
+        if (this._type === "link") {
+            this._href = this._toRealUrl(value);
+        }
+    }
+    get href() {
+        return this._href;
+    }
+}
+exports.FakeElement = FakeElement;
+class FakeSheet {
+    constructor(element, basePath) {
+        this._element = element;
+        this._basePath = basePath;
+        this.cachedCss = undefined;
+        this.cachedCssRules = undefined;
+    }
+    get css() {
+        if (this.cachedCss) {
+            return this.cachedCss;
+        }
+        let css = fs.readFileSync(path.resolve(this._basePath, this._element.href
+            .replace(/^https:\/\/test\.cases\/path\//, "")
+            .replace(/^https:\/\/example\.com\//, "")), "utf-8");
+        css = css.replace(/@import url\("([^"]+)"\);/g, (match, url) => {
+            if (!/^https:\/\/test\.cases\/path\//.test(url)) {
+                return `@import url("${url}");`;
+            }
+            if (url.startsWith("#")) {
+                return url;
+            }
+            return fs.readFileSync(path.resolve(this._basePath, url.replace(/^https:\/\/test\.cases\/path\//, "")), "utf-8");
+        });
+        this.cachedCss = css;
+        return css;
+    }
+    get cssRules() {
+        if (this.cachedCssRules) {
+            return this.cachedCssRules;
+        }
+        const walkCssTokens = require("./walkCssTokens");
+        const rules = [];
+        let currentRule = { getPropertyValue };
+        let selector = undefined;
+        let last = 0;
+        const processDeclaration = str => {
+            const colon = str.indexOf(":");
+            if (colon > 0) {
+                const property = str.slice(0, colon).trim();
+                const value = str.slice(colon + 1);
+                currentRule[property] = value;
+            }
+        };
+        const filepath = /file:\/\//.test(this._element.href)
+            ? new URL(this._element.href)
+            : path.resolve(this._basePath, this._element.href
+                .replace(/^https:\/\/test\.cases\/path\//, "")
+                .replace(/^https:\/\/example\.com\/public\/path\//, "")
+                .replace(/^https:\/\/example\.com\//, ""));
+        let css = fs.readFileSync(filepath.replace(/\?hmr=\d*/, ""), "utf-8");
+        css = css.replace(/@import url\("([^"]+)"\);/g, (match, url) => {
+            if (!/^https:\/\/test\.cases\/path\//.test(url)) {
+                return url;
+            }
+            if (url.startsWith("#")) {
+                return url;
+            }
+            return fs.readFileSync(path.resolve(this._basePath, url.replace(/^https:\/\/test\.cases\/path\//, "")), "utf-8");
+        })
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .replace("//", "");
+        walkCssTokens(css, {
+            isSelector() {
+                return selector === undefined;
+            },
+            leftCurlyBracket(source, start, end) {
+                if (selector === undefined) {
+                    selector = source.slice(last, start).trim();
+                    last = end;
+                }
+                return end;
+            },
+            rightCurlyBracket(source, start, end) {
+                processDeclaration(source.slice(last, start));
+                rules.push({
+                    selectorText: selector,
+                    style: currentRule,
+                    // hack cssText, css hmr needs this fields to detect changes
+                    cssText: css
+                });
+                last = end;
+                selector = undefined;
+                currentRule = { getPropertyValue };
+                return end;
+            },
+            semicolon(source, start, end) {
+                processDeclaration(source.slice(last, start));
+                last = end;
+                return end;
+            }
+        });
+        this.cachedCssRules = rules;
+        return rules;
+    }
+}
+exports.FakeSheet = FakeSheet;

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

@@ -0,0 +1,3 @@
+declare function _exports(something: any, context: any, unlinked: any): Promise<vm.Module>;
+export = _exports;
+import vm = require("node:vm");

package/dist/helper/legacy/asModule.js

@@ -0,0 +1,25 @@
+"use strict";
+// @ts-nocheck
+const vm = require("node:vm");
+const SYNTHETIC_MODULES_STORE = "__SYNTHETIC_MODULES_STORE";
+module.exports = async (something, context, unlinked) => {
+    if (something instanceof (vm.Module || /* node.js 10 */ vm.SourceTextModule)) {
+        return something;
+    }
+    context[SYNTHETIC_MODULES_STORE] = context[SYNTHETIC_MODULES_STORE] || [];
+    const i = context[SYNTHETIC_MODULES_STORE].length;
+    context[SYNTHETIC_MODULES_STORE].push(something);
+    const code = [...new Set(["default", ...Object.keys(something)])]
+        .map(name => `const _${name} = ${SYNTHETIC_MODULES_STORE}[${i}]${name === "default" ? "" : `[${JSON.stringify(name)}]`}; export { _${name} as ${name}};`)
+        .join("\n");
+    const m = new vm.SourceTextModule(code, {
+        context
+    });
+    if (unlinked)
+        return m;
+    await m.link(() => { });
+    if (m.instantiate)
+        m.instantiate();
+    await m.evaluate();
+    return m;
+};

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

@@ -0,0 +1,8 @@
+declare function _exports(stdio: any, tty: any): {
+    data: any[];
+    reset: () => never[];
+    toString: () => string;
+    toStringRaw: () => string;
+    restore(): void;
+};
+export = _exports;

package/dist/helper/legacy/captureStdio.js

@@ -0,0 +1,32 @@
+"use strict";
+// @ts-nocheck
+const { stripVTControlCharacters: stripAnsi } = require("node:util");
+module.exports = (stdio, tty) => {
+    let logs = [];
+    const write = stdio.write;
+    const isTTY = stdio.isTTY;
+    stdio.write = str => {
+        logs.push(str);
+    };
+    if (tty !== undefined)
+        stdio.isTTY = tty;
+    return {
+        data: logs,
+        reset: () => (logs = []),
+        toString: () => {
+            return stripAnsi(logs.join("")).replace(/\([^)]+\) (\[[^\]]+\]\s*)?(Deprecation|Experimental)Warning.+(\n\(Use .node.+\))?(\n(\s|BREAKING CHANGE).*)*(\n\s+at .*)*\n?/g, "");
+        },
+        toStringRaw: () => {
+            return logs.join("");
+        },
+        restore() {
+            stdio.write = write;
+            stdio.isTTY = isTTY;
+            delete require.cache[require.resolve("../../")];
+            // delete require.cache[
+            // 	require.resolve("../../lib/node/NodeEnvironmentPlugin")
+            // ];
+            // delete require.cache[require.resolve("../../lib/node/nodeConsole")];
+        }
+    };
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(testDirectory: any, object: any, kind: any, filename: any, upperCaseKind: any, done: any): Promise<true | undefined>;
+export = _exports;

package/dist/helper/legacy/checkArrayExpectation.js

@@ -0,0 +1,111 @@
+// @ts-nocheck
+"use strict";
+const fs = require("graceful-fs");
+const path = require("node:path");
+const check = (expected, actual) => {
+    if (expected instanceof RegExp) {
+        expected = { message: expected };
+    }
+    if (Array.isArray(expected)) {
+        return expected.every(e => check(e, actual));
+    }
+    return Object.keys(expected).every(key => {
+        let value = actual[key];
+        if (typeof value === "object") {
+            value = JSON.stringify(value);
+        }
+        return expected[key].test(value);
+    });
+};
+const explain = object => {
+    if (object instanceof RegExp) {
+        object = { message: object };
+    }
+    return Object.keys(object)
+        .map(key => {
+        let value = object[key];
+        if (typeof value === "object" && !(value instanceof RegExp)) {
+            value = JSON.stringify(value);
+        }
+        let msg = `${key} = ${value}`;
+        if (key !== "stack" && key !== "details" && msg.length > 600)
+            msg = msg.slice(0, 597) + "...";
+        return msg;
+    })
+        .join("; ");
+};
+const diffItems = (actual, expected, kind) => {
+    const tooMuch = actual.slice();
+    const missing = expected.slice();
+    for (let i = 0; i < missing.length; i++) {
+        const current = missing[i];
+        for (let j = 0; j < tooMuch.length; j++) {
+            if (check(current, tooMuch[j])) {
+                tooMuch.splice(j, 1);
+                missing.splice(i, 1);
+                i--;
+                break;
+            }
+        }
+    }
+    const diff = [];
+    if (missing.length > 0) {
+        diff.push(`The following expected ${kind}s are missing:
+${missing.map(item => `${explain(item)}`).join("\n\n")}`);
+    }
+    if (tooMuch.length > 0) {
+        diff.push(`The following ${kind}s are unexpected:
+${tooMuch.map(item => `${explain(item)}`).join("\n\n")}`);
+    }
+    return diff.join("\n\n");
+};
+module.exports = async function checkArrayExpectation(testDirectory, object, kind, filename, upperCaseKind, done) {
+    const usePromise = typeof done === "function";
+    done = typeof done === "function" ? done : error => {
+        throw error;
+    };
+    let array = object[`${kind}s`];
+    if (Array.isArray(array)) {
+        if (kind === "warning") {
+            array = array.filter(item => !/from Terser/.test(item));
+        }
+    }
+    if (fs.existsSync(path.join(testDirectory, `${filename}.js`))) {
+        // CHANGE: added file for sorting messages in multi-thread environment
+        if (fs.existsSync(path.join(testDirectory, `${filename}-sort.js`))) {
+            const sorter = require(path.join(testDirectory, `${filename}-sort.js`));
+            array = sorter(array);
+        }
+        const expectedFilename = path.join(testDirectory, `${filename}.js`);
+        const expected = require(expectedFilename);
+        const diff = diffItems(array, expected, kind);
+        if (expected.length < array.length) {
+            done(new Error(`More ${kind}s (${array.length} instead of ${expected.length}) while compiling than expected:\n\n${diff}\n\nCheck expected ${kind}s: ${expectedFilename}`));
+            return true;
+        }
+        if (expected.length > array.length) {
+            done(new Error(`Less ${kind}s (${array.length} instead of ${expected.length}) while compiling than expected:\n\n${diff}\n\nCheck expected ${kind}s: ${expectedFilename}`));
+            return true;
+        }
+        for (let i = 0; i < array.length; i++) {
+            if (Array.isArray(expected[i])) {
+                for (let j = 0; j < expected[i].length; j++) {
+                    if (!check(expected[i][j], array[i])) {
+                        done(new Error(`${upperCaseKind} ${i}: ${explain(array[i])} doesn't match ${explain(expected[i][j])}`));
+                        return true;
+                    }
+                }
+            }
+            else if (!check(expected[i], array[i])) {
+                done(new Error(`${upperCaseKind} ${i}: ${explain(array[i])} doesn't match ${explain(expected[i])}`));
+                return true;
+            }
+        }
+    }
+    else if (array.length > 0) {
+        done(new Error(`${upperCaseKind}s while compiling:\n\n${array
+            .map(explain)
+            .join("\n\n")}`));
+        return true;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(src: any, dest: any, initial: any): void;
+export = _exports;

package/dist/helper/legacy/copyDiff.js

@@ -0,0 +1,33 @@
+"use strict";
+// @ts-nocheck
+const fs = require("node:fs");
+const path = require("node:path");
+const { rimrafSync } = require("rimraf");
+module.exports = function copyDiff(src, dest, initial) {
+    fs.mkdirSync(dest, { recursive: true });
+    const files = fs.readdirSync(src);
+    for (const filename of files) {
+        const srcFile = path.join(src, filename);
+        const destFile = path.join(dest, filename);
+        const directory = fs.statSync(srcFile).isDirectory();
+        if (directory) {
+            copyDiff(srcFile, destFile, initial);
+        }
+        else {
+            const content = fs.readFileSync(srcFile);
+            if (/^DELETE\s*$/.test(content.toString("utf-8"))) {
+                fs.unlinkSync(destFile);
+            }
+            else if (/^DELETE_DIRECTORY\s*$/.test(content.toString("utf-8"))) {
+                rimrafSync(destFile);
+            }
+            else {
+                fs.writeFileSync(destFile, content);
+                if (initial) {
+                    const longTimeAgo = Date.now() - 1000 * 60 * 60 * 24;
+                    fs.utimesSync(destFile, Date.now() - longTimeAgo, Date.now() - longTimeAgo);
+                }
+            }
+        }
+    }
+};

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

@@ -0,0 +1,13 @@
+declare function _exports(env: any, { outputDirectory }: {
+    outputDirectory: any;
+}): {
+    new (url: any, options?: {}): {
+        url: any;
+        worker: import("worker_threads").Worker;
+        _onmessage: ((data: any) => void) | undefined;
+        onmessage: any;
+        postMessage(data: any): void;
+        terminate(): Promise<number>;
+    };
+};
+export = _exports;

package/dist/helper/legacy/createFakeWorker.js

@@ -0,0 +1,80 @@
+"use strict";
+// @ts-nocheck
+const path = require("node:path");
+module.exports = (env, { outputDirectory }) => class Worker {
+    constructor(url, options = {}) {
+        env.expect(url).toBeInstanceOf(URL);
+        env.expect(url.origin).toBe("https://test.cases");
+        env.expect(url.pathname.startsWith("/path/")).toBe(true);
+        this.url = url;
+        const file = url.pathname.slice(6);
+        const workerBootstrap = `
+const { parentPort } = require("worker_threads");
+const { URL } = require("url");
+const path = require("path");
+const fs = require("fs");
+global.self = global;
+self.URL = URL;
+self.location = new URL(${JSON.stringify(url.toString())});
+const urlToPath = url => {
+	if(url.startsWith("https://test.cases/path/")) url = url.slice(24);
+	return path.resolve(${JSON.stringify(outputDirectory)}, \`./\${url}\`);
+};
+self.importScripts = url => {
+	${options.type === "module"
+            ? `throw new Error("importScripts is not supported in module workers")`
+            : "require(urlToPath(url))"};
+};
+self.fetch = async url => {
+	try {
+		const buffer = await new Promise((resolve, reject) =>
+			fs.readFile(urlToPath(url), (err, b) =>
+				err ? reject(err) : resolve(b)
+			)
+		);
+		return {
+			status: 200,
+			ok: true,
+			json: async () => JSON.parse(buffer.toString("utf-8"))
+		};
+	} catch(err) {
+		if(err.code === "ENOENT") {
+			return {
+				status: 404,
+				ok: false
+			};
+		}
+		throw err;
+	}
+};
+parentPort.on("message", data => {
+	if(self.onmessage) self.onmessage({
+		data
+	});
+});
+self.postMessage = data => {
+	parentPort.postMessage(data);
+};
+require(${JSON.stringify(path.resolve(outputDirectory, file))});
+`;
+        this.worker = new (require("node:worker_threads").Worker)(workerBootstrap, {
+            eval: true
+        });
+        this._onmessage = undefined;
+    }
+    set onmessage(value) {
+        if (this._onmessage)
+            this.worker.off("message", this._onmessage);
+        this.worker.on("message", (this._onmessage = data => {
+            value({
+                data
+            });
+        }));
+    }
+    postMessage(data) {
+        this.worker.postMessage(data);
+    }
+    terminate() {
+        return this.worker.terminate();
+    }
+};

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

@@ -0,0 +1,10 @@
+declare function _exports(globalTimeout?: number, nameSuffix?: string): {
+    setDefaultTimeout(time: any): void;
+    getNumberOfTests(): number;
+    it(...args: any[]): void;
+    beforeEach(...args: any[]): void;
+    afterEach(...args: any[]): void;
+    expect: jest.Expect;
+    jest: typeof jest;
+};
+export = _exports;