@rspack/test-tools 2.0.1 → 2.0.3

package/dist/case/treeshaking.js

@@ -1,50 +1,81 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTreeShakingCase = createTreeShakingCase;
-const creator_1 = require("../test/creator");
-const builtin_1 = require("./builtin");
-const common_1 = require("./common");
-const creator = new creator_1.BasicCaseCreator({
+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__, {
+    createTreeShakingCase: ()=>createTreeShakingCase
+});
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_builtin_js_namespaceObject = require("./builtin.js");
+const external_common_js_namespaceObject = require("./common.js");
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    description(name, step) {
+    description (name, step) {
         return `${name} with newTreeshaking should match snapshot`;
     },
-    steps: ({ name }) => [
-        {
-            config: async (context) => {
-                const compiler = context.getCompiler();
-                const options = (0, builtin_1.defaultOptions)(context);
-                overrideOptions(context, options);
-                compiler.setOptions(options);
-            },
-            compiler: async (context) => {
-                await (0, common_1.compiler)(context, name);
-            },
-            build: async (context) => {
-                await (0, common_1.build)(context, name);
-            },
-            run: async (env, context) => {
-                // no need to run, just check snapshot
-            },
-            check: async (env, context) => {
-                await (0, common_1.checkSnapshot)(env, context, name, 'treeshaking.snap.txt');
-            },
-        },
-    ],
+    steps: ({ name })=>[
+            {
+                config: (context)=>{
+                    const compiler = context.getCompiler();
+                    const options = (0, external_builtin_js_namespaceObject.defaultOptions)(context);
+                    overrideOptions(context, options);
+                    compiler.setOptions(options);
+                },
+                compiler: async (context)=>{
+                    await (0, external_common_js_namespaceObject.compiler)(context, name);
+                },
+                build: async (context)=>{
+                    await (0, external_common_js_namespaceObject.build)(context, name);
+                },
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
+                    await (0, external_common_js_namespaceObject.checkSnapshot)(env, context, name, 'treeshaking.snap.txt');
+                }
+            }
+        ]
 });
 function createTreeShakingCase(name, src, dist) {
     creator.create(name, src, dist);
 }
 function overrideOptions(context, options) {
-    options.target = options.target || ['web', 'es2022'];
+    options.target = options.target || [
+        'web',
+        'es2022'
+    ];
     options.optimization ??= {};
     options.optimization.providedExports = true;
     options.optimization.innerGraph = true;
     options.optimization.usedExports = true;
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
-        };
-    }
+    if (!global.printLogger) options.infrastructureLogging = {
+        level: 'error'
+    };
 }
+exports.createTreeShakingCase = __webpack_exports__.createTreeShakingCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTreeShakingCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/watch.d.ts

@@ -1,28 +1,12 @@
-import type { ITestContext, ITestEnv, ITestRunner } from '../type';
+import type { ITestContext, ITestEnv, ITestProcessor, ITestRunner } from '../type';
 export declare function createWatchInitialProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher }?: {
     incremental?: boolean | undefined;
     nativeWatcher?: boolean | undefined;
-}): {
-    before: (context: ITestContext) => Promise<void>;
-    config: (context: ITestContext) => Promise<void>;
-    compiler: (context: ITestContext) => Promise<void>;
-    build: (context: ITestContext) => Promise<void>;
-    run: (env: ITestEnv, context: ITestContext) => Promise<void>;
-    check: (env: ITestEnv, context: ITestContext) => Promise<void>;
-    after: (context: ITestContext) => Promise<void>;
-};
+}): ITestProcessor;
 export declare function createWatchStepProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher }?: {
     incremental?: boolean | undefined;
     nativeWatcher?: boolean | undefined;
-}): {
-    before: (context: ITestContext) => Promise<void>;
-    config: (context: ITestContext) => Promise<void>;
-    compiler: (context: ITestContext) => Promise<void>;
-    build: (context: ITestContext) => Promise<void>;
-    run: (env: ITestEnv, context: ITestContext) => Promise<void>;
-    check: (env: ITestEnv, context: ITestContext) => Promise<void>;
-    after: (context: ITestContext) => Promise<void>;
-};
+}): ITestProcessor;
 export declare function createWatchCase(name: string, src: string, dist: string, temp: string): void;
 export declare function getWatchRunnerKey(context: ITestContext, name: string, file: string): string;
 export declare function createWatchRunner(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;