@rspack/test-tools 2.0.2 → 2.0.3

package/dist/case/hook.js

@@ -1,199 +1,205 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HookCasesContext = void 0;
-exports.createHookCase = createHookCase;
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = require("@rspack/core");
-const jest_snapshot_1 = require("jest-snapshot");
-const path_serializer_1 = require("path-serializer");
-const pretty_format_1 = require("pretty-format");
-const rspack_merge_1 = __importDefault(require("rspack-merge"));
-const context_1 = require("../test/context");
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    HookCasesContext: ()=>HookCasesContext,
+    createHookCase: ()=>createHookCase
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const core_namespaceObject = require("@rspack/core");
+const external_jest_snapshot_namespaceObject = require("jest-snapshot");
+const external_path_serializer_namespaceObject = require("path-serializer");
+const external_pretty_format_namespaceObject = require("pretty-format");
+const external_rspack_merge_namespaceObject = require("rspack-merge");
+var external_rspack_merge_default = /*#__PURE__*/ __webpack_require__.n(external_rspack_merge_namespaceObject);
+const context_js_namespaceObject = require("../test/context.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
 const srcDir = __TEST_FIXTURES_PATH__;
-const distDir = node_path_1.default.resolve(__TEST_DIST_PATH__, 'hook');
-const creator = new creator_1.BasicCaseCreator({
+const distDir = external_node_path_default().resolve(__TEST_DIST_PATH__, 'hook');
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: true,
-    createContext: (config) => new HookCasesContext(config.src, config.name, config),
-    steps: ({ name, caseConfig: _caseConfig, src }) => {
+    createContext: (config)=>new HookCasesContext(config.src, config.name, config),
+    steps: ({ name, caseConfig: _caseConfig, src })=>{
         const caseConfig = _caseConfig;
         return [
             {
-                config: async (context) => {
+                config: async (context)=>{
                     const compiler = context.getCompiler();
-                    const options = await (0, common_1.config)(context, name, ['rspack.config.js', 'webpack.config.js'], defaultOptions(context, caseConfig.options));
-                    if (!global.printLogger) {
-                        options.infrastructureLogging = {
-                            level: 'error',
-                        };
-                    }
+                    const options = await (0, external_common_js_namespaceObject.config)(context, name, [
+                        'rspack.config.js',
+                        'webpack.config.js'
+                    ], hook_defaultOptions(context, caseConfig.options));
+                    if (!global.printLogger) options.infrastructureLogging = {
+                        level: 'error'
+                    };
                     compiler.setOptions(options);
                 },
-                compiler: async (context) => {
-                    const c = await (0, common_1.compiler)(context, name);
-                    if (caseConfig.compiler) {
-                        await caseConfig.compiler(context, c);
-                    }
-                },
-                build: async (context) => {
-                    await (0, common_1.build)(context, name);
+                compiler: async (context)=>{
+                    const c = await (0, external_common_js_namespaceObject.compiler)(context, name);
+                    if (caseConfig.compiler) await caseConfig.compiler(context, c);
                 },
-                run: async (env, context) => {
-                    // no need to run, just check snapshot
+                build: async (context)=>{
+                    await (0, external_common_js_namespaceObject.build)(context, name);
                 },
-                check: async (env, context) => {
-                    await (0, common_1.checkSnapshot)(env, context, name, node_path_1.default.join(src, 'output.snap.txt'), caseConfig.snapshotFileFilter);
-                },
-            },
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
+                    await (0, external_common_js_namespaceObject.checkSnapshot)(env, context, name, external_node_path_default().join(src, 'output.snap.txt'), caseConfig.snapshotFileFilter);
+                }
+            }
         ];
-    },
+    }
 });
 function createHookCase(name, src, dist, source) {
-    const caseConfig = require(node_path_1.default.join(src, 'test.js'));
-    const testName = node_path_1.default.basename(name.slice(0, name.indexOf(node_path_1.default.extname(name))));
-    creator.create(name, src, dist, undefined, {
+    const caseConfig = require(external_node_path_default().join(src, 'test.js'));
+    const testName = external_node_path_default().basename(name.slice(0, name.indexOf(external_node_path_default().extname(name))));
+    creator.create(name, src, dist, void 0, {
         caseConfig,
-        description: () => caseConfig.description,
-        createContext: (config) => new HookCasesContext(src, testName, {
-            src: source,
-            dist: dist,
-            name: name,
-        }),
+        description: ()=>caseConfig.description,
+        createContext: (config)=>new HookCasesContext(src, testName, {
+                src: source,
+                dist: dist,
+                name: name
+            })
     });
 }
 const sourceSerializer = {
-    test(val) {
-        return val instanceof core_1.sources.Source;
+    test (val) {
+        return val instanceof core_namespaceObject.sources.Source;
     },
-    print(val) {
+    print (val) {
         return val.source();
-    },
+    }
 };
 const internalSerializer = {
-    test(val) {
-        return val instanceof core_1.Compiler || val instanceof core_1.Compilation;
+    test (val) {
+        return val instanceof core_namespaceObject.Compiler || val instanceof core_namespaceObject.Compilation;
     },
-    print(val) {
+    print (val) {
         return JSON.stringify(`${val.constructor.name}(internal ignored)`);
-    },
+    }
 };
-const testPathSerializer = (0, path_serializer_1.createSnapshotSerializer)({
+const testPathSerializer = (0, external_path_serializer_namespaceObject.createSnapshotSerializer)({
     replace: [
         {
             match: srcDir,
-            mark: '<HOOK_SRC_DIR>',
+            mark: '<HOOK_SRC_DIR>'
         },
         {
             match: distDir,
-            mark: '<HOOK_DIST_DIR>',
-        },
-    ],
+            mark: '<HOOK_DIST_DIR>'
+        }
+    ]
 });
 const escapeRegex = true;
 const printFunctionName = false;
-const normalizeNewlines = (str) => str.replace(/\r\n|\r/g, '\n');
-const serialize = (val, indent = 2, formatOverrides = {}) => normalizeNewlines((0, pretty_format_1.format)(val, {
-    escapeRegex,
-    indent,
-    plugins: [
-        ...(0, jest_snapshot_1.getSerializers)(),
-        sourceSerializer,
-        internalSerializer,
-        testPathSerializer,
-    ],
-    printFunctionName,
-    ...formatOverrides,
-}));
-class HookCasesContext extends context_1.TestContext {
-    constructor(src, testName, options) {
-        super(options);
-        this.src = src;
-        this.testName = testName;
-        this.options = options;
-        this.promises = [];
-        this.count = 0;
-        this.snapshots = {};
-        this.snapshotsList = [];
+const normalizeNewlines = (str)=>str.replace(/\r\n|\r/g, '\n');
+const serialize = (val, indent = 2, formatOverrides = {})=>normalizeNewlines((0, external_pretty_format_namespaceObject.format)(val, {
+        escapeRegex,
+        indent,
+        plugins: [
+            ...(0, external_jest_snapshot_namespaceObject.getSerializers)(),
+            sourceSerializer,
+            internalSerializer,
+            testPathSerializer
+        ],
+        printFunctionName,
+        ...formatOverrides
+    }));
+class HookCasesContext extends context_js_namespaceObject.TestContext {
+    src;
+    testName;
+    options;
+    promises = [];
+    count = 0;
+    snapshots = {};
+    snapshotsList = [];
+    constructor(src, testName, options){
+        super(options), this.src = src, this.testName = testName, this.options = options;
         this.snapped = this.snapped.bind(this);
     }
-    /**
-     * Snapshot function arguments and return value.
-     * Generated snapshot is located in the same directory with the test source.
-     * @example
-     * compiler.hooks.compilation("name", context.snapped((...args) => { ... }))
-     */
     snapped(cb, prefix = '') {
-        // eslint-disable-next-line
         const context = this;
-        return function SNAPPED_HOOK(...args) {
+        return function(...args) {
             const group = prefix ? prefix : context.count++;
             context._addSnapshot(args, 'input', group);
             const output = cb.apply(this, args);
-            if (output && typeof output.then === 'function') {
+            if (output && 'function' == typeof output.then) {
                 let resolve;
-                context.promises.push(new Promise((r) => (resolve = r)));
-                return output
-                    .then((o) => {
+                context.promises.push(new Promise((r)=>resolve = r));
+                return output.then((o)=>{
                     context._addSnapshot(o, 'output (Promise resolved)', group);
                     return o;
-                })
-                    .catch((o) => {
+                }).catch((o)=>{
                     context._addSnapshot(o, 'output (Promise rejected)', group);
                     return o;
-                })
-                    .finally(resolve);
+                }).finally(resolve);
             }
             context._addSnapshot(output, 'output', group);
             return output;
         };
     }
-    /**
-     * @internal
-     */
     _addSnapshot(content, name, group) {
-        const normalizedContent = Buffer.isBuffer(content)
-            ? content
-            : serialize(content, undefined, {
-                escapeString: true,
-                printBasicPrototype: true,
-            }).replace(/\r\n/g, '\n');
+        const normalizedContent = Buffer.isBuffer(content) ? content : serialize(content, void 0, {
+            escapeString: true,
+            printBasicPrototype: true
+        }).replace(/\r\n/g, '\n');
         (this.snapshots[group] = this.snapshots[group] || []).push([
             normalizedContent,
-            name,
+            name
         ]);
-        if (!this.snapshotsList.includes(group)) {
-            this.snapshotsList.push(group);
-        }
+        if (!this.snapshotsList.includes(group)) this.snapshotsList.push(group);
     }
-    /**
-     * @internal
-     */
     async collectSnapshots(env, options = {
-        diff: {},
+        diff: {}
     }) {
         await Promise.allSettled(this.promises);
-        if (!this.snapshotsList.length)
-            return;
-        const snapshots = this.snapshotsList.reduce((acc, group, index) => {
-            const block = this.snapshots[group || index].reduce((acc, [content, name]) => {
+        if (!this.snapshotsList.length) return;
+        const snapshots = this.snapshotsList.reduce((acc, group, index)=>{
+            const block = this.snapshots[group || index].reduce((acc, [content, name])=>{
                 name = `## ${name || `test: ${index}`}\n\n`;
                 const block = `\`\`\`javascript\n${content}\n\`\`\`\n`;
                 return `${acc}${name + block}\n`;
             }, '');
             return `${acc}# ${Number.isInteger(group) ? `Group: ${index}` : group}\n\n${block}`;
         }, '');
-        env
-            .expect(snapshots)
-            .toMatchFileSnapshotSync(node_path_1.default.join(this.src, 'hooks.snap.txt'), options);
+        env.expect(snapshots).toMatchFileSnapshotSync(external_node_path_default().join(this.src, 'hooks.snap.txt'), options);
     }
 }
-exports.HookCasesContext = HookCasesContext;
-function defaultOptions(context, custom) {
+function hook_defaultOptions(context, custom) {
     let defaultOptions = {
         context: context.getSource(),
         mode: 'production',
@@ -204,24 +210,31 @@ function defaultOptions(context, custom) {
         output: {
             path: context.getDist(),
             bundlerInfo: {
-                force: false,
-            },
+                force: false
+            }
         },
         module: {
             defaultRules: [
                 '...',
                 {
                     test: /\.css$/i,
-                    type: 'css/auto',
-                },
-            ],
+                    type: 'css/auto'
+                }
+            ]
         },
         optimization: {
-            minimize: false,
-        },
+            minimize: false
+        }
     };
-    if (custom) {
-        defaultOptions = (0, rspack_merge_1.default)(defaultOptions, custom(context));
-    }
+    if (custom) defaultOptions = external_rspack_merge_default()(defaultOptions, custom(context));
     return defaultOptions;
 }
+exports.HookCasesContext = __webpack_exports__.HookCasesContext;
+exports.createHookCase = __webpack_exports__.createHookCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HookCasesContext",
+    "createHookCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});