@rspack/test-tools 2.0.1 → 2.0.3

package/dist/helper/legacy/createLazyTestEnv.js

@@ -1,63 +1,74 @@
 "use strict";
-// @ts-nocheck
-module.exports = (globalTimeout = 2000, nameSuffix = '') => {
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createLazyTestEnv: ()=>createLazyTestEnv
+});
+function createLazyTestEnv(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;
+    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(() => {
+        rfn = fn.length >= 1 ? (done)=>{
+            fn((...args)=>{
+                if (isTest) runTests++;
+                done(...args);
+            });
+        } : ()=>{
+            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', () => {
+    describe(nameSuffix ? `exported tests ${nameSuffix}` : 'exported tests', ()=>{
+        it('should run the exported tests', ()=>{
             runTests++;
         });
-        afterAll(() => {
-            for (const dispose of disposables) {
-                dispose();
-            }
+        afterAll(()=>{
+            for (const dispose of disposables)dispose();
         });
         currentDescribeBlock = state.currentDescribeBlock;
         currentlyRunningTest = state.currentlyRunningTest;
     });
     let numberOfTests = 0;
-    const inSuite = (fn) => {
-        const { currentDescribeBlock: oldCurrentDescribeBlock, currentlyRunningTest: oldCurrentlyRunningTest, hasStarted: oldHasStarted, } = state;
+    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
+        } catch (e) {
             e.stack;
             throw e;
         }
@@ -65,52 +76,52 @@ module.exports = (globalTimeout = 2000, nameSuffix = '') => {
         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
+    const fixAsyncError = (block)=>{
         block.asyncError = {
-            stack: block.asyncError.stack,
+            stack: block.asyncError.stack
         };
     };
     return {
-        setDefaultTimeout(time) {
+        setDefaultTimeout (time) {
             globalTimeout = time;
         },
-        getNumberOfTests() {
+        getNumberOfTests () {
             return numberOfTests;
         },
-        it(...args) {
+        it (...args) {
             numberOfTests++;
-            if (runTests >= numberOfTests)
-                throw new Error('it called too late');
+            if (runTests >= numberOfTests) throw new Error('it called too late');
             args[1] = createDisposableFn(args[1], true);
             args[2] = args[2] || globalTimeout;
-            inSuite(() => {
+            inSuite(()=>{
                 it(...args);
                 fixAsyncError(currentDescribeBlock.tests[currentDescribeBlock.tests.length - 1]);
             });
         },
-        beforeEach(...args) {
-            if (runTests >= numberOfTests)
-                throw new Error('beforeEach called too late');
+        beforeEach (...args) {
+            if (runTests >= numberOfTests) throw new Error('beforeEach called too late');
             args[0] = createDisposableFn(args[0]);
-            inSuite(() => {
+            inSuite(()=>{
                 beforeEach(...args);
                 fixAsyncError(currentDescribeBlock.hooks[currentDescribeBlock.hooks.length - 1]);
             });
         },
-        afterEach(...args) {
-            if (runTests >= numberOfTests)
-                throw new Error('afterEach called too late');
+        afterEach (...args) {
+            if (runTests >= numberOfTests) throw new Error('afterEach called too late');
             args[0] = createDisposableFn(args[0]);
-            inSuite(() => {
+            inSuite(()=>{
                 afterEach(...args);
                 fixAsyncError(currentDescribeBlock.hooks[currentDescribeBlock.hooks.length - 1]);
             });
         },
-        /** @type {import('@rstest/core').Expect} */
         expect,
-        rstest,
+        rstest
     };
-};
+}
+exports.createLazyTestEnv = __webpack_exports__.createLazyTestEnv;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLazyTestEnv"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/helper/legacy/currentScript.js

@@ -1,8 +1,41 @@
 "use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CurrentScript: ()=>CurrentScript
+});
 class CurrentScript {
-    constructor(path = '', type = 'text/javascript') {
+    constructor(path = '', type = "text/javascript"){
         this.src = `https://test.cases/path/${path}index.js`;
         this.type = type;
     }
 }
-module.exports = CurrentScript;
+exports.CurrentScript = __webpack_exports__.CurrentScript;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CurrentScript"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1 +1 @@
-export function start(handler: any): () => any[];
+export declare const start: (handler: any) => () => any[];

package/dist/helper/legacy/deprecationTracking.js

@@ -1,35 +1,60 @@
-// @ts-nocheck
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
-'use strict';
-let interception = undefined;
-const originalWarn = console.warn;
-console.warn = (message, ...args) => {
-    if (interception &&
-        typeof message === 'string' &&
-        message.includes('[Rspack Deprecation]')) {
-        interception.set(message, {
-            message,
-            stack: new Error(message).stack,
+"use strict";
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
         });
-    }
-    return originalWarn.apply(console, [message, ...args]);
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    start: ()=>start
+});
+let interception;
+const originalWarn = console.warn;
+console.warn = (message, ...args)=>{
+    if (interception && 'string' == typeof message && message.includes('[Rspack Deprecation]')) interception.set(message, {
+        message,
+        stack: new Error(message).stack
+    });
+    return originalWarn.apply(console, [
+        message,
+        ...args
+    ]);
 };
-exports.start = (handler) => {
+const start = (handler)=>{
     interception = new Map();
-    return () => {
+    return ()=>{
         const map = interception;
-        interception = undefined;
-        return Array.from(map || [])
-            .sort(([a], [b]) => {
-            if (a < b)
-                return -1;
-            if (a > b)
-                return 1;
+        interception = void 0;
+        return Array.from(map || []).sort(([a], [b])=>{
+            if (a < b) return -1;
+            if (a > b) return 1;
             return 0;
-        })
-            .map(([key, data]) => data);
+        }).map(([key, data])=>data);
     };
 };
+exports.start = __webpack_exports__.start;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "start"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -2,9 +2,10 @@
  * @param {string} source value
  * @param {string} str string for searching
  */
-export function expectSourceToContain(source: string, str: string): void;
+declare function expectSourceToContain(source: string, str: string): void;
 /**
  * @param {string} source value
  * @param {RegExp} regexStr regexp
  */
-export function expectSourceToMatch(source: string, regexStr: RegExp): void;
+declare function expectSourceToMatch(source: string, regexStr: RegExp): void;
+export { expectSourceToContain, expectSourceToMatch };

package/dist/helper/legacy/expectSource.js

@@ -1,23 +1,47 @@
-// @ts-nocheck
-'use strict';
-const regexEscape = require('./regexEscape');
-// These expect* methods are necessary because 'source' contains the code for this test file, which will always contain the string
-// being tested for, so we have to use the "DO NOT MATCH BELOW..." technique to exclude the actual testing code from the test.
-// Place your jest 'expect' calls below a line containing the DO NOT MATCH BELOW... string constructed below.  See other tests for examples.
-// Break up the match string so we don't match it in these expect* functions either.
-const doNotMatch = ['DO', 'NOT', 'MATCH', 'BELOW', 'THIS', 'LINE'].join(' ');
-/**
- * @param {string} source value
- * @param {string} str string for searching
- */
+"use strict";
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    expectSourceToContain: ()=>expectSourceToContain,
+    expectSourceToMatch: ()=>expectSourceToMatch
+});
+const external_regexEscape_js_namespaceObject = require("./regexEscape.js");
+const doNotMatch = "DO NOT MATCH BELOW THIS LINE";
 function expectSourceToContain(source, str) {
-    expect(source).toMatch(new RegExp(`${regexEscape(str)}.*${doNotMatch}`, 's'));
+    expect(source).toMatch(new RegExp(`${(0, external_regexEscape_js_namespaceObject.regexEscape)(str)}.*${doNotMatch}`, 's'));
 }
-/**
- * @param {string} source value
- * @param {RegExp} regexStr regexp
- */
 function expectSourceToMatch(source, regexStr) {
     expect(source).toMatch(new RegExp(`${regexStr}.*${doNotMatch}`, 's'));
 }
-module.exports = { expectSourceToContain, expectSourceToMatch };
+exports.expectSourceToContain = __webpack_exports__.expectSourceToContain;
+exports.expectSourceToMatch = __webpack_exports__.expectSourceToMatch;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "expectSourceToContain",
+    "expectSourceToMatch"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,9 +1,12 @@
-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;
+declare const System: {
+    register: (name: any, deps: any, fn: any) => void;
+    set: (name: any, exports: any) => void;
+    registry: undefined;
+    _require: undefined;
+    _nextName: string;
+    setRequire: (req: any) => void;
+    init: (modules: any) => void;
+    execute: (name: any) => any;
+    ensureExecuted: (name: any) => any;
+};
+export { System };

package/dist/helper/legacy/fakeSystem.js

@@ -1,11 +1,35 @@
 "use strict";
-// @ts-nocheck
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    System: ()=>System
+});
 const System = {
-    register: (name, deps, fn) => {
-        if (!System.registry) {
-            throw new Error('System is no initialized');
-        }
-        if (typeof name !== 'string') {
+    register: (name, deps, fn)=>{
+        if (!System.registry) throw new Error('System is no initialized');
+        if ('string' != typeof name) {
             fn = deps;
             deps = name;
             name = System._nextName;
@@ -14,19 +38,14 @@ const System = {
             fn = deps;
             deps = [];
         }
-        const dynamicExport = (result) => {
-            if (System.registry[name] !== entry) {
-                throw new Error(`Module ${name} calls dynamicExport too late`);
-            }
+        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)) {
+            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++) {
+                if (m.deps) for(let i = 0; i < m.deps.length; i++){
                     const dep = m.deps[i];
-                    if (dep !== name)
-                        continue;
+                    if (dep !== name) continue;
                     const setters = m.mod.setters[i];
                     setters(result);
                 }
@@ -34,23 +53,17 @@ const System = {
         };
         const systemContext = {
             meta: {
-                url: `/${name}.js`,
+                url: `/${name}.js`
             },
-            import() {
+            import () {
                 return Promise.resolve();
-            },
+            }
         };
-        if (name in System.registry) {
-            throw new Error(`Module ${name} is already registered`);
-        }
+        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`);
-            }
+            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,
@@ -58,43 +71,37 @@ const System = {
             fn,
             mod,
             executed: false,
-            exports: undefined,
+            exports: void 0
         };
         System.registry[name] = entry;
     },
-    set: (name, exports) => {
+    set: (name, exports1)=>{
         System.registry[name] = {
             name,
             executed: true,
-            exports,
+            exports: exports1
         };
     },
-    registry: undefined,
-    _require: undefined,
+    registry: void 0,
+    _require: void 0,
     _nextName: '(anonym)',
-    setRequire: (req) => {
+    setRequire: (req)=>{
         System._require = req;
     },
-    init: (modules) => {
+    init: (modules)=>{
         System.registry = {};
-        if (modules) {
-            for (const name of Object.keys(modules)) {
-                System.registry[name] = {
-                    executed: true,
-                    exports: modules[name],
-                };
-            }
-        }
+        if (modules) for (const name of Object.keys(modules))System.registry[name] = {
+            executed: true,
+            exports: modules[name]
+        };
     },
-    execute: (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`);
+        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) => {
+    ensureExecuted: (name)=>{
         let m = System.registry[name];
         if (!m && System._require) {
             const oldName = System._nextName;
@@ -103,22 +110,25 @@ const System = {
             System._nextName = oldName;
             m = System.registry[name];
         }
-        if (!m) {
-            throw new Error(`Module ${name} not registered`);
-        }
+        if (!m) throw new Error(`Module ${name} not registered`);
         if (!m.executed) {
             m.executed = true;
-            for (let i = 0; i < m.deps.length; i++) {
+            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);
+                const { exports: exports1 } = System.registry[dep];
+                if (void 0 !== exports1) setters(exports1);
             }
             m.mod.execute();
         }
         return m.exports;
-    },
+    }
 };
-module.exports = System;
+exports.System = __webpack_exports__.System;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "System"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,6 +1,11 @@
-declare function _exports(options: {
+/**
+ * @param {{output: {path: string}}} options options
+ * @param {RegExp} regexp regexp
+ * @param {string=} subpath path in output directory
+ * @returns {string[]} files
+ */
+export declare function findOutputFiles(options: {
     output: {
         path: string;
     };
 }, regexp: RegExp, subpath?: string | undefined): string[];
-export = _exports;