@rspack-debug/test-tools 1.3.14

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022-present Bytedance, Inc. and its affiliates.
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+<picture>
+  <img alt="Rspack Banner" src="https://assets.rspack.rs/rspack/rspack-banner.png">
+</picture>
+
+# @rspack/test-tools
+
+> Rspack's internal test tools, don't use it directly in your project, it may contain breaking change in minor & patch release right now.
+
+Test tools for rspack.
+
+## Documentation
+
+See [https://rspack.rs](https://rspack.rs) for details.
+
+## License
+
+Rspack is [MIT licensed](https://github.com/web-infra-dev/rspack/blob/main/LICENSE).

package/dist/case/builtin.d.ts

@@ -0,0 +1 @@
+export declare function createBuiltinCase(name: string, src: string, dist: string): void;

package/dist/case/builtin.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinCase = createBuiltinCase;
+const node_path_1 = __importDefault(require("node:path"));
+const processor_1 = require("../processor");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const FILTERS = {
+    "plugin-css": (file) => file.endsWith(".css"),
+    "plugin-css-modules": (file) => file.endsWith(".css") ||
+        (file.endsWith(".js") && !file.includes("runtime")),
+    "plugin-html": (file) => file.endsWith(".html")
+};
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    description(name) {
+        return `${name} should match snapshot`;
+    },
+    steps: ({ name, src }) => {
+        const cat = node_path_1.default.basename(node_path_1.default.dirname(src));
+        const filter = FILTERS[cat];
+        return [
+            new processor_1.BuiltinProcessor({
+                name,
+                snapshot: "output.snap.txt",
+                snapshotFileFilter: filter,
+                compilerType: type_1.ECompilerType.Rspack
+            })
+        ];
+    },
+    concurrent: true
+});
+function createBuiltinCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/cache.d.ts

@@ -0,0 +1,2 @@
+import { ECompilerType, type TCompilerOptions } from "../type";
+export declare function createCacheCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], temp: string): void;

package/dist/case/cache.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCacheCase = createCacheCase;
+const cache_1 = require("../processor/cache");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creators = new Map();
+function getCreator(target) {
+    if (!creators.has(target)) {
+        creators.set(target, new creator_1.BasicCaseCreator({
+            clean: true,
+            describe: true,
+            target,
+            steps: ({ name, src, target, temp }) => [
+                new cache_1.CacheProcessor({
+                    name,
+                    sourceDir: src,
+                    tempDir: temp,
+                    target: target,
+                    compilerType: type_1.ECompilerType.Rspack,
+                    configFiles: ["rspack.config.js", "webpack.config.js"]
+                })
+            ],
+            runner: runner_1.CacheRunnerFactory,
+            concurrent: true
+        }));
+    }
+    return creators.get(target);
+}
+function createCacheCase(name, src, dist, target, temp) {
+    const creator = getCreator(target);
+    creator.create(name, src, dist, temp);
+}

package/dist/case/compiler.d.ts

@@ -0,0 +1,6 @@
+import { type ISimpleProcessorOptions } from "../processor";
+import { ECompilerType } from "../type";
+export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+    description: string;
+};
+export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/compiler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompilerCase = createCompilerCase;
+const processor_1 = require("../processor");
+const simple_1 = require("../test/simple");
+const type_1 = require("../type");
+function createCompilerCase(name, src, dist, testConfig) {
+    const caseConfig = require(testConfig);
+    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
+    it(caseConfig.description, async () => {
+        await runner(name, new processor_1.SimpleTaskProcessor({
+            name: name,
+            compilerType: type_1.ECompilerType.Rspack,
+            ...caseConfig
+        }));
+    });
+}

package/dist/case/config.d.ts

@@ -0,0 +1,3 @@
+import { ECompilerType, type TTestConfig } from "../type";
+export type TConfigCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+export declare function createConfigCase(name: string, src: string, dist: string): void;

package/dist/case/config.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigCase = createConfigCase;
+const config_1 = require("../processor/config");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    testConfig: testConfig => {
+        const oldModuleScope = testConfig.moduleScope;
+        testConfig.moduleScope = (ms, stats) => {
+            let res = ms;
+            // TODO: modify runner module scope based on stats here
+            if (typeof oldModuleScope === "function") {
+                res = oldModuleScope(ms, stats);
+            }
+            return res;
+        };
+    },
+    steps: ({ name }) => [
+        new config_1.ConfigProcessor({
+            name,
+            runable: true,
+            compilerType: type_1.ECompilerType.Rspack,
+            configFiles: [
+                "rspack.config.cjs",
+                "rspack.config.js",
+                "webpack.config.js"
+            ]
+        })
+    ],
+    runner: runner_1.MultipleRunnerFactory,
+    concurrent: true
+});
+function createConfigCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/defaults.d.ts

@@ -0,0 +1,6 @@
+import { type IDefaultsConfigProcessorOptions } from "../processor";
+import { ECompilerType } from "../type";
+export type TDefaultsCaseConfig = Omit<IDefaultsConfigProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+    description: string;
+};
+export declare function createDefaultsCase(name: string, src: string): void;

package/dist/case/defaults.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultsCase = createDefaultsCase;
+const node_path_1 = __importDefault(require("node:path"));
+const processor_1 = require("../processor");
+const context_1 = require("../test/context");
+const type_1 = require("../type");
+const srcDir = node_path_1.default.resolve(__dirname, "../../tests/fixtures");
+const distDir = node_path_1.default.resolve(__dirname, "../../tests/js/defaults");
+const context = new context_1.TestContext({
+    src: srcDir,
+    dist: distDir
+});
+async function run(name, processor) {
+    try {
+        await processor.before?.(context);
+        await processor.config?.(context);
+    }
+    catch (e) {
+        context.emitError(name, e);
+    }
+    finally {
+        await processor.check?.({ expect, it, beforeEach, afterEach, jest }, context);
+        await processor.after?.(context);
+    }
+}
+function createDefaultsCase(name, src) {
+    const caseConfig = require(src);
+    it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
+        await run(name, new processor_1.DefaultsConfigProcessor({
+            name,
+            compilerType: type_1.ECompilerType.Rspack,
+            ...caseConfig
+        }));
+    });
+}

package/dist/case/diagnostic.d.ts

@@ -0,0 +1 @@
+export declare function createDiagnosticCase(name: string, src: string, dist: string): void;

package/dist/case/diagnostic.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiagnosticCase = createDiagnosticCase;
+const processor_1 = require("../processor");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name }) => [
+        new processor_1.DiagnosticProcessor({
+            name,
+            snapshot: "./stats.err",
+            snapshotErrors: "./raw-error.err",
+            snapshotWarning: "./raw-warning.err",
+            configFiles: ["rspack.config.js", "webpack.config.js"],
+            compilerType: type_1.ECompilerType.Rspack,
+            format: (output) => {
+                // TODO: change to stats.errorStack
+                // TODO: add `errorStack: false`
+                return output.replace(/(│.* at ).*/g, "$1xxx");
+            }
+        })
+    ],
+    concurrent: true
+});
+function createDiagnosticCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/diff.d.ts

@@ -0,0 +1,3 @@
+import { type IDiffProcessorOptions } from "../processor";
+export type TDiffCaseConfig = IDiffProcessorOptions;
+export declare function createDiffCase(name: string, src: string, dist: string): void;

package/dist/case/diff.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiffCase = createDiffCase;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const rimraf_1 = require("rimraf");
+const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
+const processor_1 = require("../processor");
+const tester_1 = require("../test/tester");
+const type_1 = require("../type");
+const DEFAULT_CASE_CONFIG = {
+    webpackPath: require.resolve("webpack"),
+    rspackPath: require.resolve("@rspack/core"),
+    files: ["bundle.js"],
+    bootstrap: true,
+    detail: true,
+    errors: false
+};
+function createDiffCase(name, src, dist) {
+    const caseConfigFile = node_path_1.default.join(src, "test.config.js");
+    if (!fs_extra_1.default.existsSync(caseConfigFile)) {
+        return;
+    }
+    const caseConfig = Object.assign({}, DEFAULT_CASE_CONFIG, require(caseConfigFile));
+    const [processor, compareMap] = createDiffProcessor(caseConfig);
+    const tester = new tester_1.Tester({
+        name,
+        src,
+        dist,
+        steps: [processor]
+    });
+    (0, rimraf_1.rimrafSync)(dist);
+    const prefix = node_path_1.default.basename(name);
+    describe(`${prefix}:check`, () => {
+        beforeAll(async () => {
+            await tester.compile();
+            compareMap.clear();
+            await tester.check(env);
+        });
+        for (const file of caseConfig.files) {
+            describe(`Comparing "${file}"`, () => {
+                let moduleResults = [];
+                let runtimeResults = [];
+                beforeAll(() => {
+                    const fileResult = compareMap.get(file);
+                    if (!fileResult) {
+                        throw new Error(`File ${file} has no results`);
+                    }
+                    moduleResults = fileResult.modules;
+                    runtimeResults = fileResult.runtimeModules;
+                });
+                if (caseConfig.modules) {
+                    checkCompareResults("modules", () => moduleResults);
+                }
+                if (caseConfig.runtimeModules) {
+                    checkCompareResults("runtime modules", () => runtimeResults);
+                }
+            });
+        }
+        const env = (0, createLazyTestEnv_1.default)(1000);
+    });
+}
+function createDiffProcessor(config) {
+    const fileCompareMap = new Map();
+    const createCompareResultHandler = (type) => {
+        return (file, results) => {
+            const fileResult = fileCompareMap.get(file) || {
+                modules: [],
+                runtimeModules: []
+            };
+            fileResult[type] = results;
+            fileCompareMap.set(file, fileResult);
+        };
+    };
+    const processor = new processor_1.DiffProcessor({
+        webpackPath: config.webpackPath,
+        rspackPath: config.rspackPath,
+        files: config.files,
+        modules: config.modules,
+        runtimeModules: config.runtimeModules,
+        renameModule: config.renameModule,
+        ignoreModuleId: config.ignoreModuleId ?? true,
+        ignoreModuleArguments: config.ignoreModuleArguments ?? true,
+        ignorePropertyQuotationMark: config.ignorePropertyQuotationMark ?? true,
+        ignoreBlockOnlyStatement: config.ignoreBlockOnlyStatement ?? true,
+        ignoreIfCertainCondition: config.ignoreIfCertainCondition ?? true,
+        ignoreSwcHelpersPath: config.ignoreSwcHelpersPath ?? true,
+        ignoreObjectPropertySequence: config.ignoreObjectPropertySequence ?? true,
+        ignoreCssFilePath: config.ignoreCssFilePath ?? true,
+        onCompareModules: createCompareResultHandler("modules"),
+        onCompareRuntimeModules: createCompareResultHandler("runtimeModules"),
+        bootstrap: config.bootstrap ?? true,
+        detail: config.detail ?? true,
+        errors: config.errors ?? false,
+        replacements: config.replacements
+    });
+    return [processor, fileCompareMap];
+}
+function checkCompareResults(name, getResults) {
+    describe(`Comparing ${name}`, () => {
+        it("should not miss any module", () => {
+            expect(getResults()
+                .filter(i => i.type === type_1.ECompareResultType.Missing)
+                .map(i => i.name)).toEqual([]);
+        });
+        it("should not have any rspack-only module", () => {
+            expect(getResults()
+                .filter(i => i.type === type_1.ECompareResultType.OnlySource)
+                .map(i => i.name)).toEqual([]);
+        });
+        it("should not have any webpack-only module", () => {
+            expect(getResults()
+                .filter(i => i.type === type_1.ECompareResultType.OnlyDist)
+                .map(i => i.name)).toEqual([]);
+        });
+        it("all modules should be the same", () => {
+            for (const result of getResults().filter(i => i.type === type_1.ECompareResultType.Different)) {
+                console.log(`${result.name}:\n${result.detail}`);
+            }
+            expect(getResults().every(i => i.type === type_1.ECompareResultType.Same)).toEqual(true);
+        });
+    });
+}

package/dist/case/error.d.ts

@@ -0,0 +1,6 @@
+import { type IErrorProcessorOptions } from "../processor";
+import { ECompilerType } from "../type";
+export type TErrorCaseConfig = Omit<IErrorProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+    description: string;
+};
+export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorCase = createErrorCase;
+const processor_1 = require("../processor");
+const simple_1 = require("../test/simple");
+const type_1 = require("../type");
+let addedSerializer = false;
+function createErrorCase(name, src, dist, testConfig) {
+    if (!addedSerializer) {
+        addedSerializer = true;
+    }
+    const caseConfig = require(testConfig);
+    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
+    it(caseConfig.description, async () => {
+        await runner(name, new processor_1.ErrorProcessor({
+            name: name,
+            compilerType: type_1.ECompilerType.Rspack,
+            ...caseConfig
+        }));
+    });
+}

package/dist/case/hash.d.ts

@@ -0,0 +1,3 @@
+import { ECompilerType, type TTestConfig } from "../type";
+export type THashCaseConfig = Pick<TTestConfig<ECompilerType.Rspack>, "validate">;
+export declare function createHashCase(name: string, src: string, dist: string): void;

package/dist/case/hash.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHashCase = createHashCase;
+const processor_1 = require("../processor");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+class HashCaseCreator extends creator_1.BasicCaseCreator {
+    describe(name, tester, testConfig) {
+        it(`should print correct hash for ${name}`, async () => {
+            await tester.prepare();
+            await tester.compile();
+            await tester.check(this.createEnv(testConfig));
+            await tester.resume();
+        }, 30000);
+    }
+}
+const creator = new HashCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name }) => [
+        new processor_1.HashProcessor({
+            name,
+            compilerType: type_1.ECompilerType.Rspack,
+            configFiles: ["rspack.config.js", "webpack.config.js"]
+        })
+    ]
+});
+function createHashCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/hook.d.ts

@@ -0,0 +1,6 @@
+import { type IHookProcessorOptions } from "../processor";
+import { ECompilerType } from "../type";
+export type THookCaseConfig = Omit<IHookProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType" | "runable"> & {
+    description: string;
+};
+export declare function createHookCase(name: string, src: string, dist: string, source: string): void;

package/dist/case/hook.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHookCase = createHookCase;
+const node_path_1 = __importDefault(require("node:path"));
+const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
+const processor_1 = require("../processor");
+const runner_1 = require("../runner");
+const simple_1 = require("../test/simple");
+const type_1 = require("../type");
+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))));
+    const runner = (0, simple_1.getSimpleProcessorRunner)(source, dist, {
+        env: () => env,
+        context: () => new processor_1.HookCasesContext(src, testName, {
+            src: source,
+            dist: dist,
+            runnerFactory: runner_1.BasicRunnerFactory
+        })
+    });
+    it(caseConfig.description, async () => {
+        await runner(name, new processor_1.HookTaskProcessor({
+            name,
+            compilerType: type_1.ECompilerType.Rspack,
+            findBundle: () => ["main.js"],
+            snapshot: node_path_1.default.join(src, "output.snap.txt"),
+            runable: true,
+            ...caseConfig
+        }));
+    });
+    const env = (0, createLazyTestEnv_1.default)(10000);
+}

package/dist/case/hot-step.d.ts

@@ -0,0 +1,2 @@
+import { ECompilerType, type TCompilerOptions } from "../type";
+export declare function createHotStepCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;

package/dist/case/hot-step.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHotStepCase = createHotStepCase;
+const hot_step_1 = require("../processor/hot-step");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creators = new Map();
+function getCreator(target) {
+    if (!creators.has(target)) {
+        creators.set(target, new creator_1.BasicCaseCreator({
+            clean: true,
+            describe: false,
+            target,
+            steps: ({ name, target }) => [
+                new hot_step_1.HotSnapshotProcessor({
+                    name,
+                    target: target,
+                    compilerType: type_1.ECompilerType.Rspack,
+                    configFiles: ["rspack.config.js", "webpack.config.js"]
+                })
+            ],
+            runner: runner_1.HotStepRunnerFactory,
+            concurrent: true
+        }));
+    }
+    return creators.get(target);
+}
+function createHotStepCase(name, src, dist, target) {
+    const creator = getCreator(target);
+    creator.create(name, src, dist);
+}

package/dist/case/hot.d.ts

@@ -0,0 +1,2 @@
+import { ECompilerType, type TCompilerOptions } from "../type";
+export declare function createHotCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;

package/dist/case/hot.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHotCase = createHotCase;
+const hot_1 = require("../processor/hot");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creators = new Map();
+function getCreator(target) {
+    if (!creators.has(target)) {
+        creators.set(target, new creator_1.BasicCaseCreator({
+            clean: true,
+            describe: true,
+            target,
+            steps: ({ name, target }) => [
+                new hot_1.HotProcessor({
+                    name,
+                    target: target,
+                    compilerType: type_1.ECompilerType.Rspack,
+                    configFiles: ["rspack.config.js", "webpack.config.js"]
+                })
+            ],
+            runner: runner_1.HotRunnerFactory,
+            concurrent: true
+        }));
+    }
+    return creators.get(target);
+}
+function createHotCase(name, src, dist, target) {
+    const creator = getCreator(target);
+    creator.create(name, src, dist);
+}

package/dist/case/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./builtin";
+export * from "./compiler";
+export * from "./config";
+export * from "./defaults";
+export * from "./diagnostic";
+export * from "./diff";
+export * from "./error";
+export * from "./hash";
+export * from "./hook";
+export * from "./hot";
+export * from "./hot-step";
+export * from "./normal";
+export * from "./stats-api";
+export * from "./stats-output";
+export * from "./treeshaking";
+export * from "./watch";
+export * from "./new-incremental";
+export * from "./cache";
+export * from "./serial";

package/dist/case/index.js

@@ -0,0 +1,35 @@
+"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("./builtin"), exports);
+__exportStar(require("./compiler"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./defaults"), exports);
+__exportStar(require("./diagnostic"), exports);
+__exportStar(require("./diff"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./hash"), exports);
+__exportStar(require("./hook"), exports);
+__exportStar(require("./hot"), exports);
+__exportStar(require("./hot-step"), exports);
+__exportStar(require("./normal"), exports);
+__exportStar(require("./stats-api"), exports);
+__exportStar(require("./stats-output"), exports);
+__exportStar(require("./treeshaking"), exports);
+__exportStar(require("./watch"), exports);
+__exportStar(require("./new-incremental"), exports);
+__exportStar(require("./cache"), exports);
+__exportStar(require("./serial"), exports);

package/dist/case/new-incremental.d.ts

@@ -0,0 +1,6 @@
+import { ECompilerType, type TCompilerOptions } from "../type";
+export declare function createHotNewIncrementalCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
+export type WatchNewIncrementalOptions = {
+    ignoreNotFriendlyForIncrementalWarnings?: boolean;
+};
+export declare function createWatchNewIncrementalCase(name: string, src: string, dist: string, temp: string, options?: WatchNewIncrementalOptions): void;