@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/inner-plugins/constants.js

@@ -1,5 +1,5 @@
 import "node:module";
-const pluginTapName = 'RsdoctorWebpackPlugin';
+const pluginTapName = 'RsdoctorRspackPlugin';
 const pluginTapPostOptions = {
     name: pluginTapName,
     stage: 999

package/dist/inner-plugins/loaders/proxy.d.ts

@@ -1,7 +1,7 @@
-import type { Plugin as PluginType } from '@rsdoctor/types';
-import { Plugin } from '@rsdoctor/types';
+import type { Plugin as PluginType } from '@rsdoctor/shared/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import type { ProxyLoaderOptions } from '../../types/index.js';
-declare const loaderModule: Plugin.LoaderDefinition<ProxyLoaderOptions, {}>;
-export declare const pitch: (this: PluginType.LoaderContext<ProxyLoaderOptions>) => string | void | Buffer<ArrayBufferLike> | Promise<string | Buffer<ArrayBufferLike>>;
+declare const loaderModule: Plugin.LoaderDefinition<ProxyLoaderOptions, object>;
+export declare const pitch: (this: PluginType.LoaderContext<ProxyLoaderOptions>) => void | string | Buffer<ArrayBufferLike> | Promise<string | Buffer<ArrayBufferLike>>;
 export declare const raw = true;
 export default loaderModule;

package/dist/inner-plugins/plugins/base.d.ts

@@ -1,4 +1,4 @@
-import type { Linter, Plugin, SDK } from '@rsdoctor/types';
+import type { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
 import type { InternalPlugin, RsdoctorPluginInstance } from '../../types/index.js';
 export declare abstract class InternalBasePlugin<T extends Plugin.BaseCompiler> implements InternalPlugin<T, Linter.ExtendRuleData[]> {
     readonly scheduler: RsdoctorPluginInstance<T, Linter.ExtendRuleData[]>;

package/dist/inner-plugins/plugins/bundle.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalBundlePlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "bundle";

package/dist/inner-plugins/plugins/bundle.js

@@ -1,8 +1,8 @@
 import "node:module";
-import { Manifest } from "@rsdoctor/types";
+import { Manifest } from "@rsdoctor/shared/types";
 import { InternalBasePlugin } from "./base.js";
-import { Chunks } from "@rsdoctor/graph";
-import { logger, time, timeEnd } from "@rsdoctor/utils/logger";
+import { Chunks } from "../../graph/index.js";
+import { logger, time, timeEnd } from "../../logger.js";
 class InternalBundlePlugin extends InternalBasePlugin {
     apply(compiler) {
         time('InternalBundlePlugin.apply');
@@ -37,28 +37,12 @@ class InternalBundlePlugin extends InternalBasePlugin {
         super(...args), this.name = 'bundle', this.map = new Map(), this.thisCompilation = (compilation)=>{
             time('InternalBundlePlugin.thisCompilation');
             try {
-                if (compilation.hooks.processAssets && 'afterOptimizeAssets' in compilation.hooks) compilation.hooks.afterOptimizeAssets.tap(this.tapPostOptions, (assets)=>{
+                if (compilation.hooks.processAssets) compilation.hooks.afterProcessAssets.tap(this.tapPostOptions, (assets)=>{
                     Object.keys(assets).forEach((file)=>{
                         const v = this.ensureAssetContent(file);
                         v.content = assets[file].source().toString();
                     });
                 });
-                else if (compilation.hooks.processAssets && 'afterProcessAssets' in compilation.hooks) compilation.hooks.afterProcessAssets.tap(this.tapPostOptions, ()=>{
-                    Object.keys(compilation.assets).forEach((file)=>{
-                        const v = this.ensureAssetContent(file);
-                        v.content = compilation.assets[file].source().toString();
-                    });
-                });
-                else if ('afterOptimizeChunkAssets' in compilation.hooks) compilation.hooks.afterOptimizeChunkAssets.tap(this.tapPostOptions, (chunks)=>{
-                    [
-                        ...chunks
-                    ].reduce((t, chunk)=>t.concat([
-                            ...chunk.files
-                        ]), []).forEach((file)=>{
-                        const v = this.ensureAssetContent(file);
-                        v.content = compilation.assets[file].source().toString();
-                    });
-                });
             } finally{
                 timeEnd('InternalBundlePlugin.thisCompilation');
             }

package/dist/inner-plugins/plugins/ensureModulesChunkGraph.d.ts

@@ -1,5 +1,5 @@
-import { RsdoctorPluginInstance } from '../../types/index.js';
-import { Linter, Plugin } from '@rsdoctor/types';
+import type { RsdoctorPluginInstance } from '../../types/index.js';
+import { Linter, Plugin } from '@rsdoctor/shared/types';
 /**
  * Represents a mapping item from a source map.
  */
@@ -12,22 +12,20 @@ export interface MappingItem {
     name: string | null;
 }
 /**
- * Main function to generate ModuleGraph and ChunkGraph from stats and Webpack module APIs.
- * Sets up hooks to process stats, generate graphs, handle tree shaking, and collect source maps.
- * @param compiler - The Webpack or Rspack compiler instance.
- * @param _this - The Rsdoctor plugin instance.
+ * Main function to generate ModuleGraph and ChunkGraph from Rspack native data
+ * and collect source maps.
  */
 export declare const ensureModulesChunksGraphFn: (compiler: Plugin.BaseCompiler, _this: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>) => void;
 /**
  * Checks if source map processing is enabled and supported by the current compiler configuration.
  * Warns if eval-based source maps are used (unsupported).
- * @param compiler - The Webpack or Rspack compiler instance.
+ * @param compiler - The Rspack compiler instance.
  * @returns true if source maps are enabled and supported, false otherwise.
  */
 export declare const ensureDevtools: (compiler: Plugin.BaseCompiler) => boolean;
 /**
  * Calculates namespace and source map filename regex for source map resolution.
- * @param compiler - The Webpack or Rspack compiler instance.
+ * @param compiler - The Rspack compiler instance.
  * @returns An object containing namespace and sourceMapFilenameRegex.
  */
 export declare function calculateNamespaceAndRegex(compiler: Plugin.BaseCompiler): {

package/dist/inner-plugins/plugins/ensureModulesChunkGraph.js

@@ -1,25 +1,18 @@
 import "node:module";
-import { Manifest } from "@rsdoctor/types";
-import { Process } from "@rsdoctor/utils/build";
-import { chalk, logger } from "@rsdoctor/utils/logger";
-import { Chunks, ModuleGraph } from "../../build-utils/build/index.js";
+import { chalk, logger } from "../../logger.js";
+import { Chunks } from "../../build-utils/build/index.js";
 import { internalPluginTapPreOptions, pluginTapPostOptions } from "../constants.js";
-import { applyRspackNativePlugin } from "./rspack.js";
-import { handleAfterEmitAssets, handleEmitAssets } from "./sourcemapTool.js";
+import { applyRspackNativePlugin, getRspackNativePlugin } from "./rspack.js";
+import { handleAfterEmitAssets } from "./sourcemapTool.js";
 let hasConsole = false;
 const ensureModulesChunksGraphFn = (compiler, _this)=>{
     if (_this._modulesGraphApplied) return;
+    const RsdoctorRspackPlugin = getRspackNativePlugin(compiler);
     _this._modulesGraphApplied = true;
-    const context = {
-        astCache: new Map(),
-        packagePathMap: new Map(),
-        getSourceMap: (file)=>_this.sdk.getSourceMap(file)
-    };
-    const RsdoctorRspackPlugin = compiler.webpack.experiments?.RsdoctorPlugin;
-    if (RsdoctorRspackPlugin) applyRspackNativePlugin(compiler, _this, RsdoctorRspackPlugin);
+    const nativeGraphState = applyRspackNativePlugin(compiler, _this, RsdoctorRspackPlugin);
     if (!_this._realSourcePathCache) _this._realSourcePathCache = new Map();
-    compiler.hooks.done.tapPromise(internalPluginTapPreOptions('moduleGraph'), async (_stats)=>{
-        await doneHandler(_stats, _this, context, compiler);
+    compiler.hooks.done.tapPromise(internalPluginTapPreOptions('moduleGraph'), async ()=>{
+        await doneHandler(_this, compiler, nativeGraphState);
     });
     compiler.hooks.compilation.tap({
         ...pluginTapPostOptions,
@@ -34,55 +27,14 @@ const ensureModulesChunksGraphFn = (compiler, _this)=>{
             await handleAfterEmitAssets(compilation, _this, sourceMapFilenameRegex, namespace);
         });
     });
-    compiler.hooks.emit.tapAsync({
-        ...pluginTapPostOptions,
-        stage: pluginTapPostOptions.stage + 100
-    }, emitHandler.bind(null, _this, compiler));
 };
-async function doneHandler(_stats, _this, context, compiler) {
-    const stats = _stats;
-    const getStatsJson = (()=>{
-        let cached = null;
-        return ()=>{
-            if (cached) return cached;
-            cached = stats.toJson({
-                all: false,
-                chunks: true,
-                modules: true,
-                chunkModules: true,
-                assets: true,
-                ids: true,
-                hash: true,
-                errors: true,
-                warnings: true,
-                nestedModules: true,
-                cachedModules: true,
-                orphanModules: true,
-                runtimeModules: true,
-                optimizationBailout: true
-            });
-            return cached;
-        };
-    })();
-    logger.debug(`${(Process.getMemoryUsageMessage(), '[Before Generate ModuleGraph]')}`);
-    if (!_this.chunkGraph?.getChunks().length) _this.chunkGraph = Chunks.chunkTransform(new Map(), getStatsJson());
-    if (!_this.modulesGraph.getModules().length) _this.modulesGraph = await ModuleGraph.getModuleGraphByStats(stats.compilation, getStatsJson(), process.cwd(), _this.chunkGraph, _this.options.features, context);
-    logger.debug(`${(Process.getMemoryUsageMessage(), '[After Generate ModuleGraph]')}`);
-    if (_this.options.features.treeShaking) {
-        if ('rspackVersion' in compiler.webpack) logger.info(chalk.yellow('Rspack currently does not support treeShaking capabilities.'));
-        else {
-            _this.modulesGraph = ModuleGraph.appendTreeShaking(_this.modulesGraph, stats.compilation) || _this.modulesGraph;
-            _this.sdk.addClientRoutes([
-                Manifest.RsdoctorManifestClientRoutes.TreeShaking
-            ]);
-        }
-        logger.debug(`${(Process.getMemoryUsageMessage(), '[After AppendTreeShaking to ModuleGraph]')}`);
-    }
+async function doneHandler(_this, compiler, nativeGraphState) {
+    if (!nativeGraphState.chunkGraph || !_this.chunkGraph) throw new Error('[RsdoctorRspackPlugin] The Rspack native plugin did not provide chunk graph data.');
+    if (!nativeGraphState.moduleGraph) throw new Error('[RsdoctorRspackPlugin] The Rspack native plugin did not provide module graph data.');
     const shouldParseBundle = false !== _this.options.supports.parseBundle;
     await getModulesInfos(compiler, _this.modulesGraph, _this.chunkGraph, shouldParseBundle, _this.sourceMapSets, _this.assetsWithoutSourceMap);
-    logger.debug(`${Process.getMemoryUsageMessage()}, '[After Transform ModuleGraph]'`);
     logger.debug('reportModuleGraph start');
-    if (_this.modulesGraph) await _this.sdk.reportModuleGraph(_this.modulesGraph);
+    await _this.sdk.reportModuleGraph(_this.modulesGraph);
     logger.debug('reportModuleGraph done');
     logger.debug('reportChunkGraph start');
     await _this.sdk.reportChunkGraph(_this.chunkGraph);
@@ -97,12 +49,6 @@ const ensureDevtools = (compiler)=>{
         hasConsole = true;
         return false;
     }
-    if ('rspack' in compiler) return true;
-    const sourceMapEnabled = 'string' == typeof devtool && /source-?map/i.test(devtool);
-    if (!sourceMapEnabled) {
-        logger.debug('SourceMap is not enabled. Skipping sourcemap processing.');
-        return false;
-    }
     return true;
 };
 async function getModulesInfos(compiler, moduleGraph, chunkGraph, parseBundle, sourceMapSets, assetsWithoutSourceMap) {
@@ -125,15 +71,4 @@ function calculateNamespaceAndRegex(compiler) {
         sourceMapFilenameRegex
     };
 }
-async function emitHandler(_this, compiler, compilation, callback) {
-    if (!ensureDevtools(compiler)) return void callback();
-    const { namespace, sourceMapFilenameRegex } = calculateNamespaceAndRegex(compiler);
-    await handleEmitAssets({
-        compilation,
-        pluginInstance: _this,
-        sourceMapFilenameRegex,
-        namespace
-    });
-    callback();
-}
 export { calculateNamespaceAndRegex, ensureDevtools, ensureModulesChunksGraphFn };

package/dist/inner-plugins/plugins/errors.d.ts

@@ -1,11 +1,11 @@
-import { Rule, Err, Plugin } from '@rsdoctor/types';
+import { Rule, Err, Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
-import { DevToolError } from '@rsdoctor/utils/error';
+import { DevToolError } from '../../error/index.js';
 export declare class InternalErrorReporterPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "error-reporter";
     apply(compiler: T): void;
     done: (stats: Plugin.BaseStats) => Promise<void>;
-    handleWebpackError(err: Plugin.BuildError, category: Rule.RuleMessageCategory, level: keyof typeof Err.ErrorLevel): DevToolError;
+    handleBundlerError(err: Plugin.BuildError, category: Rule.RuleMessageCategory, level: keyof typeof Err.ErrorLevel): DevToolError;
     reportWarnings(warnings: Plugin.BuildError[]): Promise<void>;
     reportErrors(errors: Plugin.BuildWarning[]): Promise<void>;
 }

package/dist/inner-plugins/plugins/errors.js

@@ -1,8 +1,8 @@
 import "node:module";
-import { Rule } from "@rsdoctor/types";
+import { Rule } from "@rsdoctor/shared/types";
 import { InternalBasePlugin } from "./base.js";
-import { DevToolError } from "@rsdoctor/utils/error";
-import { time, timeEnd } from "@rsdoctor/utils/logger";
+import { DevToolError } from "../../error/index.js";
+import { time, timeEnd } from "../../logger.js";
 class InternalErrorReporterPlugin extends InternalBasePlugin {
     apply(compiler) {
         time('InternalErrorReporterPlugin.apply');
@@ -12,7 +12,7 @@ class InternalErrorReporterPlugin extends InternalBasePlugin {
             timeEnd('InternalErrorReporterPlugin.apply');
         }
     }
-    handleWebpackError(err, category, level) {
+    handleBundlerError(err, category, level) {
         return DevToolError.from(err, {
             category,
             code: Rule.RuleMessageCodeEnumerated.Overlay,
@@ -28,7 +28,7 @@ class InternalErrorReporterPlugin extends InternalBasePlugin {
     async reportWarnings(warnings) {
         time('InternalErrorReporterPlugin.reportWarnings');
         try {
-            const arr = warnings.map((warning)=>this.handleWebpackError(warning, Rule.RuleMessageCategory.Compile, 'Warn'));
+            const arr = warnings.map((warning)=>this.handleBundlerError(warning, Rule.RuleMessageCategory.Compile, 'Warn'));
             this.sdk.reportError(arr);
         } finally{
             timeEnd('InternalErrorReporterPlugin.reportWarnings');
@@ -37,7 +37,7 @@ class InternalErrorReporterPlugin extends InternalBasePlugin {
     async reportErrors(errors) {
         time('InternalErrorReporterPlugin.reportErrors');
         try {
-            const arr = errors.map((err)=>this.handleWebpackError(err, Rule.RuleMessageCategory.Bundle, 'Error'));
+            const arr = errors.map((err)=>this.handleBundlerError(err, Rule.RuleMessageCategory.Bundle, 'Error'));
             this.sdk.reportError(arr);
         } finally{
             timeEnd('InternalErrorReporterPlugin.reportErrors');

package/dist/inner-plugins/plugins/index.d.ts

@@ -7,5 +7,4 @@ export * from './base.js';
 export * from './bundle.js';
 export * from './ensureModulesChunkGraph.js';
 export * from './rules.js';
-export * from './bundleTagPlugin.js';
 export * from './resolver.js';

package/dist/inner-plugins/plugins/index.js

@@ -8,5 +8,4 @@ export * from "./base.js";
 export * from "./bundle.js";
 export * from "./ensureModulesChunkGraph.js";
 export * from "./rules.js";
-export * from "./bundleTagPlugin.js";
 export * from "./resolver.js";

package/dist/inner-plugins/plugins/loader.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalLoaderPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "loader";

package/dist/inner-plugins/plugins/loader.js

@@ -1,16 +1,12 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { Manifest } from "@rsdoctor/types";
-import { Loader } from "@rsdoctor/utils/common";
-import { isEqual, omit } from "es-toolkit/compat";
+import "node:module";
+import { Manifest } from "@rsdoctor/shared/types";
+import { Loader } from "../../common/index.js";
+import { isEqual, omit } from "../../collection.js";
 import { interceptLoader } from "../utils/index.js";
 import { InternalBasePlugin } from "./base.js";
-import { time, timeEnd } from "@rsdoctor/utils/logger";
-import path from "path";
+import { time, timeEnd } from "../../logger.js";
 import { fileURLToPath } from "url";
 import { safeCloneDeep } from "../utils/plugin-common.js";
-const loader_filename = fileURLToPath(import.meta.url);
-const loader_dirname = path.dirname(loader_filename);
 class InternalLoaderPlugin extends InternalBasePlugin {
     apply(compiler) {
         time('InternalLoaderPlugin.apply');
@@ -92,24 +88,16 @@ class InternalLoaderPlugin extends InternalBasePlugin {
             cwd: compiler.context || process.cwd(),
             host: this.sdk.server.origin,
             skipLoaders: this.options.loaderInterceptorOptions.skipLoaders
-        }, this.sdk.root, 'resolveLoader' in compiler.options ? compiler.options.resolveLoader : {});
+        }, compiler.resolverFactory.get('loader', compiler.options.resolveLoader), this.sdk.root);
     }
     constructor(...args){
-        super(...args), this.name = 'loader', this.internalLoaderPath = (()=>{
-            const isCJS = loader_filename.endsWith('.cjs');
-            if (isCJS) return require.resolve(path.join(loader_dirname, "../loaders/proxy.cjs"));
-            try {
-                return require.resolve(path.join(loader_dirname, "../loaders/proxy.js"));
-            } catch  {
-                return require.resolve(path.join(loader_dirname, "../loaders/proxy.cjs"));
-            }
-        })(), this.afterPlugins = (compiler)=>{
+        super(...args), this.name = 'loader', this.internalLoaderPath = fileURLToPath(new URL('../loaders/proxy.js', import.meta.url)), this.afterPlugins = (compiler)=>{
             time('InternalLoaderPlugin.afterPlugins');
             try {
                 if (compiler.isChild()) return;
                 compiler.options.module.rules = this.getInterceptRules(compiler, compiler.options.module.rules);
                 this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.WebpackLoaders
+                    Manifest.RsdoctorManifestClientRoutes.Loaders
                 ]);
             } finally{
                 timeEnd('InternalLoaderPlugin.afterPlugins');

package/dist/inner-plugins/plugins/plugins.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalPluginsPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "plugins";

package/dist/inner-plugins/plugins/plugins.js

@@ -1,9 +1,9 @@
 import "node:module";
-import { Manifest } from "@rsdoctor/types";
+import { Manifest } from "@rsdoctor/shared/types";
 import { Utils } from "../../build-utils/build/index.js";
 import { interceptPluginHook } from "../utils/index.js";
 import { InternalBasePlugin } from "./base.js";
-import { time, timeEnd } from "@rsdoctor/utils/logger";
+import { time, timeEnd } from "../../logger.js";
 class InternalPluginsPlugin extends InternalBasePlugin {
     apply(compiler) {
         time('InternalPluginsPlugin.apply');
@@ -21,7 +21,7 @@ class InternalPluginsPlugin extends InternalBasePlugin {
                 if (compiler.isChild()) return;
                 Utils.interceptCompilerHooks(compiler, (name, hook)=>interceptPluginHook(this.sdk, name, hook));
                 this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.WebpackPlugins
+                    Manifest.RsdoctorManifestClientRoutes.Plugins
                 ]);
             } finally{
                 timeEnd('InternalPluginsPlugin.afterPlugins');

package/dist/inner-plugins/plugins/progress.d.ts

@@ -1,7 +1,7 @@
-import { SDK } from '@rsdoctor/types';
-import type { Plugin } from '@rsdoctor/types';
+import { SDK } from '@rsdoctor/shared/types';
+import type { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
-export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'webpack'>> extends InternalBasePlugin<T> {
+export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'rspack'>> extends InternalBasePlugin<T> {
     readonly name = "progress";
     protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgress>;
     apply(compiler: T): void;

package/dist/inner-plugins/plugins/progress.js

@@ -1,27 +1,25 @@
 import "node:module";
-import { SDK } from "@rsdoctor/types";
+import { SDK } from "@rsdoctor/shared/types";
 import { InternalBasePlugin } from "./base.js";
-import { logger } from "@rsdoctor/utils/logger";
+import { logger } from "../../logger.js";
 class InternalProgressPlugin extends InternalBasePlugin {
     apply(compiler) {
         const { sdk, currentProgress } = this;
         if (compiler.webpack && compiler.webpack.ProgressPlugin) {
-            const progress = new compiler.webpack.ProgressPlugin({
-                handler (percentage, msg) {
-                    currentProgress.percentage = percentage;
-                    currentProgress.message = msg || '';
-                    const api = SDK.ServerAPI.APIExtends.GetCompileProgress;
-                    try {
-                        sdk.server.sendAPIDataToClient(api, {
-                            req: {
-                                api,
-                                body: void 0
-                            },
-                            res: currentProgress
-                        });
-                    } catch (e) {
-                        logger.debug(e);
-                    }
+            const progress = new compiler.webpack.ProgressPlugin((percentage, msg)=>{
+                currentProgress.percentage = percentage;
+                currentProgress.message = msg || '';
+                const api = SDK.ServerAPI.APIExtends.GetCompileProgress;
+                try {
+                    sdk.server.sendAPIDataToClient(api, {
+                        req: {
+                            api,
+                            body: void 0
+                        },
+                        res: currentProgress
+                    });
+                } catch (e) {
+                    logger.debug(e);
                 }
             });
             progress.apply(compiler);

package/dist/inner-plugins/plugins/resolver.d.ts

@@ -1,6 +1,5 @@
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
-import type { Compiler as WebpackCompiler } from 'webpack';
 export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "resolver";
     protected resolveDataMap: Map<string, {
@@ -9,5 +8,5 @@ export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> exten
         request: string;
     }>;
     apply(compiler: T): void;
-    protected handleNormalModuleFactory: (normalModuleFactory: Plugin.RspackNormalModuleFactory | ReturnType<WebpackCompiler["createNormalModuleFactory"]>) => void;
+    protected handleNormalModuleFactory: (normalModuleFactory: Plugin.RspackNormalModuleFactory) => void;
 }

package/dist/inner-plugins/plugins/resolver.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { Manifest } from "@rsdoctor/types";
-import { Time } from "@rsdoctor/utils/common";
+import { Manifest } from "@rsdoctor/shared/types";
+import { Time } from "../../common/index.js";
 import { InternalBasePlugin } from "./base.js";
 class InternalResolverPlugin extends InternalBasePlugin {
     apply(compiler) {

package/dist/inner-plugins/plugins/rspack.d.ts

@@ -1,4 +1,9 @@
-import { Linter, Plugin } from '@rsdoctor/types';
+import { Linter, Plugin } from '@rsdoctor/shared/types';
 import type { experiments } from '@rspack/core';
-import { RsdoctorPluginInstance } from '../../types/index.js';
-export declare function applyRspackNativePlugin(compiler: Plugin.BaseCompiler, plugin: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>, RsdoctorRspackPlugin: typeof experiments.RsdoctorPlugin): void;
+import type { RsdoctorPluginInstance } from '../../types/index.js';
+export interface RspackNativeGraphState {
+    chunkGraph: boolean;
+    moduleGraph: boolean;
+}
+export declare function getRspackNativePlugin(compiler: Plugin.BaseCompiler): typeof experiments.RsdoctorPlugin;
+export declare function applyRspackNativePlugin(compiler: Plugin.BaseCompiler, plugin: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>, RsdoctorRspackPlugin: typeof experiments.RsdoctorPlugin): RspackNativeGraphState;

package/dist/inner-plugins/plugins/rspack.js

@@ -1,11 +1,22 @@
 import "node:module";
-import { ChunkGraph } from "@rsdoctor/graph";
+import { ChunkGraph } from "../../graph/index.js";
 import { Chunks, ModuleGraph } from "../../build-utils/build/index.js";
 import { internalPluginTapPreOptions } from "../constants.js";
-import { logger } from "@rsdoctor/utils/logger";
+import { logger } from "../../logger.js";
+function getRspackNativePlugin(compiler) {
+    const RsdoctorRspackPlugin = compiler.webpack.experiments?.RsdoctorPlugin;
+    if (!RsdoctorRspackPlugin) throw new Error('[RsdoctorRspackPlugin] The current Rspack version does not provide experiments.RsdoctorPlugin. Please upgrade Rspack.');
+    return RsdoctorRspackPlugin;
+}
 function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
+    const state = {
+        chunkGraph: false,
+        moduleGraph: false
+    };
     logger.debug('[RspackNativePlugin] Apply hooks');
     compiler.hooks.compilation.tap('RsdoctorRspackPlugin', (compilation)=>{
+        state.chunkGraph = false;
+        state.moduleGraph = false;
         const hooks = RsdoctorRspackPlugin.getCompilationHooks(compilation);
         const cached = {};
         const dependOn = {
@@ -27,16 +38,18 @@ function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
             chunkGraphData: (data)=>{
                 plugin.chunkGraph = new ChunkGraph();
                 Chunks.patchNativeChunkGraph(plugin.chunkGraph, data);
+                state.chunkGraph = true;
             },
             moduleGraphData: (data)=>{
                 ModuleGraph.patchNativeModuleGraph(plugin.modulesGraph, plugin.chunkGraph, data);
+                state.moduleGraph = true;
             },
             moduleIdsPatchData: (data)=>{
                 ModuleGraph.patchNativeModuleIds(plugin.modulesGraph, data);
             },
             moduleSourcesPatchData: (data)=>{
                 ModuleGraph.patchNativeModuleSources(plugin.modulesGraph, data);
-                ModuleGraph.extractSideEffectCodes(plugin.modulesGraph);
+                if (plugin.options.features.treeShaking) ModuleGraph.extractSideEffectCodes(plugin.modulesGraph);
             },
             assetPatchData: (data)=>{
                 Chunks.patchNativeAssets(plugin.chunkGraph, data);
@@ -81,5 +94,6 @@ function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
             tryConsumeData('assetPatchData', rawAssetPatch);
         });
     });
+    return state;
 }
-export { applyRspackNativePlugin };
+export { applyRspackNativePlugin, getRspackNativePlugin };

package/dist/inner-plugins/plugins/rules.d.ts

@@ -1,5 +1,5 @@
 import { InternalBasePlugin } from './base.js';
-import { Plugin } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/shared/types';
 export declare class InternalRulesPlugin extends InternalBasePlugin<Plugin.BaseCompiler> {
     readonly name = "rules";
     apply(compiler: Plugin.BaseCompiler): void;

package/dist/inner-plugins/plugins/rules.js

@@ -1,9 +1,9 @@
 import "node:module";
 import { InternalBasePlugin } from "./base.js";
 import { Linter } from "../../rules/index.js";
-import { DevToolError } from "@rsdoctor/utils/error";
-import { pull } from "es-toolkit/compat";
-import { time, timeEnd } from "@rsdoctor/utils/logger";
+import { DevToolError } from "../../error/index.js";
+import { pull } from "../../collection.js";
+import { time, timeEnd } from "../../logger.js";
 class InternalRulesPlugin extends InternalBasePlugin {
     apply(compiler) {
         time('InternalRulesPlugin.apply');
@@ -27,16 +27,16 @@ class InternalRulesPlugin extends InternalBasePlugin {
                 }));
             const errors = validateErrors.filter((item)=>'Error' === item.level);
             const warnings = validateErrors.filter((item)=>'Warn' === item.level);
-            const toWebpackError = (err)=>err.toError();
+            const toRspackError = (err)=>err.toError();
             result.replace.forEach((item)=>{
                 if (Array.isArray(compilation.errors) && compilation.errors.includes(item)) pull(compilation.errors, item);
                 if (Array.isArray(compilation.warnings) && compilation.warnings.includes(item)) pull(compilation.warnings, item);
             });
             if (Array.isArray(compilation.errors)) errors.forEach((err)=>{
-                compilation.warnings.push(toWebpackError(err));
+                compilation.errors.push(toRspackError(err));
             });
             if (Array.isArray(compilation.warnings)) warnings.forEach((err)=>{
-                compilation.warnings.push(toWebpackError(err));
+                compilation.warnings.push(toRspackError(err));
             });
             this.sdk.reportError(validateErrors);
             await linter.afterValidate({

package/dist/inner-plugins/plugins/sourcemapTool.d.ts

@@ -1,5 +1,5 @@
-import { RsdoctorPluginInstance } from '../../types/index.js';
-import { Linter, Plugin } from '@rsdoctor/types';
+import type { RsdoctorPluginInstance } from '../../types/index.js';
+import { Linter, Plugin } from '@rsdoctor/shared/types';
 export declare const UNASSIGNED = "[unassigned]";
 /**
  * Options for handling source map assets.

package/dist/inner-plugins/plugins/sourcemapTool.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { Graph } from "@rsdoctor/utils/common";
-import { logger, time, timeEnd } from "@rsdoctor/utils/logger";
+import { Graph } from "../../common/index.js";
+import { logger, time, timeEnd } from "../../logger.js";
 import { dirname, isAbsolute, resolve } from "path";
 import { SourceMapConsumer } from "source-map";
 const UNASSIGNED = '[unassigned]';

package/dist/inner-plugins/plugins/summary.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from '@rsdoctor/types';
+import type { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalSummaryPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "summary";

package/dist/inner-plugins/plugins/summary.js

@@ -1,8 +1,8 @@
 import "node:module";
-import { Summary } from "@rsdoctor/utils/common";
-import { minBy, sumBy } from "es-toolkit/compat";
+import { Summary } from "../../common/index.js";
+import { minBy, sumBy } from "../../collection.js";
 import { InternalBasePlugin } from "./base.js";
-import { time, timeEnd } from "@rsdoctor/utils/logger";
+import { time, timeEnd } from "../../logger.js";
 class InternalSummaryPlugin extends InternalBasePlugin {
     apply(compiler) {
         time('InternalSummaryPlugin.apply');