@rspack-debug/test-tools 1.3.14

package/dist/helper/expect/placeholder.d.ts

@@ -0,0 +1 @@
+export declare const normalizePlaceholder: (val: any) => string;

package/dist/helper/expect/placeholder.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePlaceholder = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const path_serializer_1 = require("path-serializer");
+// 1. escapeEOL \r\n -> \n
+// 2. replace <RSPACK_ROOT> etc
+// 3. transform win32 sep
+const placeholderSerializer = (0, path_serializer_1.createSnapshotSerializer)({
+    root: __dirname.includes("node_modules")
+        ? // Use `process.cwd()` when using outside Rspack
+            process.cwd()
+        : node_path_1.default.resolve(__dirname, "../../../../../"),
+    replace: [
+        {
+            match: node_path_1.default.resolve(__dirname, "../../../"),
+            mark: "test_tools_root"
+        },
+        {
+            match: node_path_1.default.resolve(__dirname, "../../../../rspack"),
+            mark: "rspack_root"
+        },
+        {
+            match: /:\d+:\d+-\d+:\d+/g,
+            mark: "line_col_range"
+        },
+        {
+            match: /:\d+:\d+/g,
+            mark: "line_col"
+        }
+    ],
+    features: {
+        replaceWorkspace: false,
+        addDoubleQuotes: false,
+        escapeDoubleQuotes: false
+    }
+});
+exports.normalizePlaceholder = placeholderSerializer.serialize;

package/dist/helper/expect/rspack.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeStats: (stats: {
+    value: string;
+}) => string;

package/dist/helper/expect/rspack.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeStats = void 0;
+const normalizeStats = (stats) => {
+    return (stats.value
+        // CHANGE: Remove potential line break and "|" caused by long text
+        .replace(/((ERROR|WARNING)([\s\S](?!╭|├))*?)(\n {2}│ )/g, "$1")
+        // CHANGE: Update the regular expression to replace the 'Rspack' version string
+        .replace(/Rspack [^ )]+(\)?) compiled/g, "Rspack x.x.x$1 compiled")
+        .replace(/(\w)\\(\w)/g, "$1/$2")
+        .replace(/, additional resolving: X ms/g, "")
+        .replace(/Unexpected identifier '.+?'/g, "Unexpected identifier"));
+};
+exports.normalizeStats = normalizeStats;

package/dist/helper/expect/to-be-typeof.d.ts

@@ -0,0 +1,4 @@
+export declare function toBeTypeOf(received: any, expected: any): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/helper/expect/to-be-typeof.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBeTypeOf = toBeTypeOf;
+// @ts-nocheck
+function toBeTypeOf(received, expected) {
+    const objType = typeof received;
+    const pass = objType === expected;
+    const message = pass
+        ? () => `${this.utils.matcherHint(".not.toBeTypeOf")}\n\nExpected value to not be (using typeof):\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(objType)}`
+        : () => `${this.utils.matcherHint(".toBeTypeOf")}\n\nExpected value to be (using typeof):\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(objType)}`;
+    return { message, pass };
+}

package/dist/helper/expect/to-end-with.d.ts

@@ -0,0 +1,4 @@
+export declare function toEndWith(received: any, expected: any): {
+    message: () => string;
+    pass: boolean;
+};

package/dist/helper/expect/to-end-with.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEndWith = toEndWith;
+// @ts-nocheck
+function toEndWith(received, expected) {
+    const pass = typeof received === "string" && received.endsWith(expected);
+    const message = pass
+        ? () => `${this.utils.matcherHint(".not.toEndWith")}\n\nExpected value to not end with:\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(received)}`
+        : () => `${this.utils.matcherHint(".toEndWith")}\n\nExpected value to end with:\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(received)}`;
+    return { message, pass };
+}

package/dist/helper/expect/to-match-file-snapshot.d.ts

@@ -0,0 +1,23 @@
+import type { FileMatcherOptions } from "../../../jest";
+/**
+ * Match given content against content of the specified file.
+ *
+ * @param content Output content to match
+ * @param filepath Path to the file to match against
+ * @param options Additional options for matching
+ */
+export declare function toMatchFileSnapshot(this: {
+    testPath: string;
+    currentTestName: string;
+    assertionCalls: number;
+    isNot: boolean;
+    snapshotState: {
+        added: number;
+        updated: number;
+        unmatched: number;
+        _updateSnapshot: "none" | "new" | "all";
+    };
+}, rawContent: string | Buffer, filepath: string, options?: FileMatcherOptions): {
+    pass: boolean;
+    message: () => string;
+};

package/dist/helper/expect/to-match-file-snapshot.js

@@ -0,0 +1,108 @@
+"use strict";
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMatchFileSnapshot = toMatchFileSnapshot;
+/* istanbul ignore file */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const chalk_1 = __importDefault(require("chalk"));
+const filenamify_1 = __importDefault(require("filenamify"));
+const jest_diff_1 = require("jest-diff");
+const serializers_1 = require("../serializers");
+const { serialize } = require(node_path_1.default.join(node_path_1.default.dirname(require.resolve("jest-snapshot")), "./utils.js"));
+// get jest builtin serializers
+const { getSerializers } = require(node_path_1.default.join(node_path_1.default.dirname(require.resolve("jest-snapshot")), "./plugins.js"));
+/**
+ * Check if 2 strings or buffer are equal
+ */
+const isEqual = (a, b) => {
+    // @ts-ignore: TypeScript gives error if we pass string to buffer.equals
+    return Buffer.isBuffer(a) ? a.equals(b) : a === b;
+};
+/**
+ * Match given content against content of the specified file.
+ *
+ * @param content Output content to match
+ * @param filepath Path to the file to match against
+ * @param options Additional options for matching
+ */
+function toMatchFileSnapshot(rawContent, filepath, options = {}) {
+    const content = Buffer.isBuffer(rawContent)
+        ? rawContent
+        : serialize(rawContent, /* ident */ 2, {
+            plugins: [
+                ...getSerializers(),
+                // Rspack serializers
+                ...serializers_1.serializers
+            ]
+        });
+    const { isNot, snapshotState } = this;
+    const filename = filepath === undefined
+        ? // If file name is not specified, generate one from the test title
+            node_path_1.default.join(node_path_1.default.dirname(this.testPath), "__file_snapshots__", `${(0, filenamify_1.default)(this.currentTestName, {
+                replacement: "-"
+            }).replace(/\s/g, "-")}-${this.assertionCalls}`)
+        : filepath;
+    if (snapshotState._updateSnapshot === "none" && !node_fs_1.default.existsSync(filename)) {
+        // We're probably running in CI environment
+        snapshotState.unmatched++;
+        return {
+            pass: isNot,
+            message: () => `New output file ${chalk_1.default.blue(node_path_1.default.basename(filename))} was ${chalk_1.default.bold.red("not written")}.\n\nThe update flag must be explicitly passed to write a new snapshot.\n\nThis is likely because this test is run in a ${chalk_1.default.blue("continuous integration (CI) environment")} in which snapshots are not written by default.\n\n`
+        };
+    }
+    if (node_fs_1.default.existsSync(filename)) {
+        const output = node_fs_1.default
+            .readFileSync(filename, Buffer.isBuffer(content) ? null : "utf8")
+            .replace(/\r\n/g, "\n");
+        if (isNot) {
+            // The matcher is being used with `.not`
+            if (!isEqual(content, output)) {
+                // The value of `pass` is reversed when used with `.not`
+                return { pass: false, message: () => "" };
+            }
+            snapshotState.unmatched++;
+            return {
+                pass: true,
+                message: () => `Expected received content ${chalk_1.default.red("to not match")} the file ${chalk_1.default.blue(node_path_1.default.basename(filename))}.`
+            };
+        }
+        if (isEqual(content, output)) {
+            return { pass: true, message: () => "" };
+        }
+        if (snapshotState._updateSnapshot === "all") {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(filename), { recursive: true });
+            node_fs_1.default.writeFileSync(filename, content);
+            snapshotState.updated++;
+            return { pass: true, message: () => "" };
+        }
+        snapshotState.unmatched++;
+        const difference = Buffer.isBuffer(content) || Buffer.isBuffer(output)
+            ? ""
+            : `\n\n${(0, jest_diff_1.diff)(output, content, Object.assign({
+                expand: false,
+                contextLines: 5,
+                aAnnotation: "Snapshot"
+            }, options.diff || {}))}`;
+        return {
+            pass: false,
+            message: () => `Received content ${chalk_1.default.red("doesn't match")} the file ${chalk_1.default.blue(node_path_1.default.basename(filename))}.${difference}`
+        };
+    }
+    if (!isNot &&
+        (snapshotState._updateSnapshot === "new" ||
+            snapshotState._updateSnapshot === "all")) {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(filename), { recursive: true });
+        node_fs_1.default.writeFileSync(filename, content);
+        snapshotState.added++;
+        return { pass: true, message: () => "" };
+    }
+    snapshotState.unmatched++;
+    return {
+        pass: true,
+        message: () => `The output file ${chalk_1.default.blue(node_path_1.default.basename(filename))} ${chalk_1.default.bold.red("doesn't exist")}.`
+    };
+}

package/dist/helper/hot-update/index.d.ts

@@ -0,0 +1 @@
+export { HotUpdatePlugin } from "./plugin";

package/dist/helper/hot-update/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HotUpdatePlugin = void 0;
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "HotUpdatePlugin", { enumerable: true, get: function () { return plugin_1.HotUpdatePlugin; } });

package/dist/helper/hot-update/loader.d.ts

@@ -0,0 +1 @@
+export default function (c: string): string;

package/dist/helper/hot-update/loader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(c) {
+    let content = c;
+    if (content.includes("NEXT_HMR")) {
+        content = `
+			${content}
+			let __hmr_children__ = [...module.children];
+      let __hmr_used_exports__ = __hmr_children__.reduce((res, child) => {
+        if (__webpack_module_cache__[child]) {
+          res[child] = __webpack_module_cache__[child].exports;
+        }
+				return res;
+			}, {});
+			module.hot.accept(__hmr_children__, () => {
+				__hmr_children__.forEach((child) => {
+					const reexports = __webpack_require__(child);
+          for (let key in reexports) {
+            if (!__hmr_used_exports__[child]) { continue; }
+						Object.defineProperty(__hmr_used_exports__[child], key, {
+							configurable: true,
+							enumerable: true,
+							get: () => reexports[key]
+						});
+					}
+				});
+			});
+		`;
+    }
+    return content.replace(/NEXT_HMR/g, "NEXT_HMR.bind(null, module)");
+}

package/dist/helper/hot-update/plugin.d.ts

@@ -0,0 +1,17 @@
+import type { Compiler } from "@rspack/core";
+export declare class HotUpdatePlugin {
+    private projectDir;
+    private tempDir;
+    private initialized;
+    private updateIndex;
+    private files;
+    constructor(projectDir: string, tempDir: string);
+    private getModifiedFiles;
+    private getContent;
+    private updateFiles;
+    initialize(): Promise<void>;
+    getUpdateIndex(): number;
+    getTotalUpdates(): number;
+    goNext(): Promise<void>;
+    apply(compiler: Compiler): void;
+}

package/dist/helper/hot-update/plugin.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HotUpdatePlugin = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+async function loopFile(dir, callback) {
+    const children = await promises_1.default.readdir(dir);
+    await Promise.all(children.map(async (filename) => {
+        const filePath = node_path_1.default.join(dir, filename);
+        const stat = await promises_1.default.stat(filePath);
+        if (stat.isFile()) {
+            const content = await promises_1.default.readFile(filePath);
+            callback(filePath, content.toString());
+        }
+        else if (stat.isDirectory()) {
+            return loopFile(filePath, callback);
+        }
+    }));
+}
+const PLUGIN_NAME = "HotUpdatePlugin";
+class HotUpdatePlugin {
+    constructor(projectDir, tempDir) {
+        this.projectDir = projectDir;
+        this.tempDir = tempDir;
+        this.initialized = false;
+        this.updateIndex = 0;
+        this.files = {};
+    }
+    getModifiedFiles() {
+        return Object.keys(this.files);
+    }
+    getContent(filePath, index) {
+        const contents = this.files[filePath] || [];
+        let content = contents[index] === undefined ? contents.at(-1) || "" : contents[index];
+        let command = "";
+        const matchResult = content.match(/^<(.+?)>([\w\W]*)$/);
+        if (matchResult) {
+            command = matchResult[1];
+            content = matchResult[2];
+        }
+        return {
+            content,
+            command
+        };
+    }
+    async updateFiles() {
+        await Promise.all(this.getModifiedFiles().map(async (filePath) => {
+            const { content, command } = this.getContent(filePath, this.updateIndex);
+            // match command
+            if (command === "delete") {
+                await promises_1.default.unlink(filePath);
+                return;
+            }
+            if (command === "force_write") {
+                await promises_1.default.writeFile(filePath, content);
+                return;
+            }
+            // default
+            const { content: oldContent } = this.getContent(filePath, this.updateIndex - 1);
+            if (content === oldContent) {
+                return;
+            }
+            await promises_1.default.writeFile(filePath, content);
+        }));
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        await promises_1.default.rmdir(this.tempDir, { recursive: true });
+        await promises_1.default.cp(this.projectDir, this.tempDir, { recursive: true });
+        await loopFile(this.tempDir, (filePath, content) => {
+            const contents = content.split(/---+\r?\n/g);
+            if (contents.length > 1) {
+                this.files[filePath] = contents;
+            }
+        });
+        await this.updateFiles();
+    }
+    getUpdateIndex() {
+        return this.updateIndex;
+    }
+    getTotalUpdates() {
+        return Object.values(this.files).reduce((max, item) => {
+            return Math.max(max, item.length);
+        }, 0);
+    }
+    async goNext() {
+        this.updateIndex++;
+        await this.updateFiles();
+    }
+    apply(compiler) {
+        const options = compiler.options;
+        options.context = this.tempDir;
+        options.module.rules ??= [];
+        options.module.rules.push({
+            test: /\.(js|css|json)/,
+            use: [
+                {
+                    loader: node_path_1.default.resolve(__dirname, "./loader.js")
+                }
+            ]
+        });
+        let isRebuild = false;
+        compiler.hooks.beforeRun.tap(PLUGIN_NAME, () => {
+            compiler.modifiedFiles = new Set(isRebuild ? this.getModifiedFiles() : []);
+            isRebuild = true;
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (_chunk, set) => {
+                set.add(compiler.webpack.RuntimeGlobals.moduleCache);
+            });
+            compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (module, _set) => {
+                if (module.constructorName === "DefinePropertyGettersRuntimeModule") {
+                    module.source.source = Buffer.from(`
+										__webpack_require__.d = function (exports, definition) {
+												for (var key in definition) {
+														if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+																Object.defineProperty(exports, key, { configurable: true, enumerable: true, get: definition[key] });
+														}
+												}
+										};
+										`, "utf-8");
+                }
+            });
+        });
+    }
+}
+exports.HotUpdatePlugin = HotUpdatePlugin;

package/dist/helper/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./directory";
+export * from "./parse-modules";
+export * from "./read-config-file";
+export * from "./update-snapshot";
+export * from "./win";
+export * from "./util/checkStats";
+export * from "./legacy/supportsImportFn";

package/dist/helper/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./directory"), exports);
+__exportStar(require("./parse-modules"), exports);
+__exportStar(require("./read-config-file"), exports);
+__exportStar(require("./update-snapshot"), exports);
+__exportStar(require("./win"), exports);
+__exportStar(require("./util/checkStats"), exports);
+__exportStar(require("./legacy/supportsImportFn"), exports);

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

@@ -0,0 +1,8 @@
+export = EventSource;
+declare class EventSource {
+    constructor(url: any);
+    response: import("http").IncomingMessage | undefined;
+    close(): void;
+    set onopen(value: any);
+    set onmessage(value: any);
+}

package/dist/helper/legacy/EventSourceForNode.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/test/helpers/EventSourceForNode.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+"use strict";
+module.exports = class EventSource {
+    constructor(url) {
+        this.response = undefined;
+        const request = (url.startsWith("https:") ? require("node:https") : require("node:http")).request(url, {
+            agent: false,
+            headers: { accept: "text/event-stream" }
+        }, res => {
+            this.response = res;
+            res.on("error", err => {
+                if (this.onerror)
+                    this.onerror(err);
+            });
+        });
+        request.on("error", err => {
+            if (this.onerror)
+                this.onerror({ message: err });
+        });
+        request.end();
+    }
+    close() {
+        this.response.destroy();
+    }
+    set onopen(value) {
+        throw new Error("not implemented");
+    }
+    set onmessage(value) {
+        throw new Error("not implemented");
+    }
+};

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

@@ -0,0 +1,54 @@
+export default class FakeDocument {
+    constructor(basePath: any, options?: {});
+    head: FakeElement;
+    body: FakeElement;
+    baseURI: string;
+    _elementsByTagName: Map<string, FakeElement[]>;
+    _basePath: any;
+    currentScript: any;
+    _options: {};
+    createElement(type: any): FakeElement;
+    _onElementAttached(element: any): void;
+    _onElementRemoved(element: any): void;
+    getElementsByTagName(name: any): FakeElement[];
+    querySelectorAll(name: any): FakeElement[];
+    getComputedStyle(element: any): {
+        getPropertyValue: (property: any) => any;
+    };
+}
+export class FakeElement {
+    constructor(document: any, type: any, basePath: any);
+    _document: any;
+    _type: any;
+    _basePath: any;
+    _children: any[];
+    _attributes: any;
+    _src: any;
+    _href: any;
+    rel: any;
+    parentNode: any;
+    sheet: FakeSheet | undefined;
+    cloneNode(): FakeElement;
+    addEventListener(): void;
+    insertBefore(node: any, before: any): void;
+    appendChild(node: any): void;
+    removeChild(node: any): void;
+    setAttribute(name: any, value: any): void;
+    removeAttribute(name: any): void;
+    getAttribute(name: any): any;
+    _toRealUrl(value: any): any;
+    set src(value: any);
+    get src(): any;
+    get children(): any[];
+    set href(value: any);
+    get href(): any;
+}
+export class FakeSheet {
+    constructor(element: any, basePath: any);
+    _element: any;
+    _basePath: any;
+    cachedCss: string | undefined;
+    cachedCssRules: any[] | undefined;
+    get css(): string;
+    get cssRules(): any[];
+}