@rsdoctor/core 2.0.0-alpha.0 → 2.0.0-alpha.1

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');

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.
  */
@@ -13,7 +13,7 @@ export interface MappingItem {
 }
 /**
  * Main function to generate ModuleGraph and ChunkGraph from Rspack native data
- * or stats fallback, and collect source maps.
+ * and collect source maps.
  */
 export declare const ensureModulesChunksGraphFn: (compiler: Plugin.BaseCompiler, _this: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>) => void;
 /**

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

@@ -1,19 +1,18 @@
 import "node:module";
-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 { 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 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, compiler);
+    compiler.hooks.done.tapPromise(internalPluginTapPreOptions('moduleGraph'), async ()=>{
+        await doneHandler(_this, compiler, nativeGraphState);
     });
     compiler.hooks.compilation.tap({
         ...pluginTapPostOptions,
@@ -29,40 +28,13 @@ const ensureModulesChunksGraphFn = (compiler, _this)=>{
         });
     });
 };
-async function doneHandler(_stats, _this, 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);
-    logger.debug(`${(Process.getMemoryUsageMessage(), '[After Generate 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);

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

@@ -1,6 +1,6 @@
-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;

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');

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,18 +88,10 @@ 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;

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');

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

@@ -1,5 +1,5 @@
-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<'rspack'>> extends InternalBasePlugin<T> {
     readonly name = "progress";

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

@@ -1,7 +1,7 @@
 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;

package/dist/inner-plugins/plugins/resolver.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 InternalResolverPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "resolver";

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');

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');

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

@@ -1,5 +1,4 @@
-import { RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../../types/index.js';
-import { Linter, Plugin, SDK } from '@rsdoctor/types';
+import { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
 export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorRspackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
 export declare const normalizeReportType: (reportCodeType: Plugin.IReportCodeType | Plugin.NewReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
-export declare function normalizeRspackUserOptions<Rules extends Linter.ExtendRuleData[]>(options: RsdoctorRspackPluginOptions<Rules>): RsdoctorRspackPluginOptionsNormalized<Rules>;
+export declare const normalizeRspackUserOptions: typeof normalizeUserConfig;

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

@@ -1,6 +1,6 @@
 import "node:module";
-import { SDK } from "@rsdoctor/types";
-import { chalk, logger } from "@rsdoctor/utils/logger";
+import { SDK } from "@rsdoctor/shared/types";
+import { chalk, logger } from "../../logger.js";
 import assert from "assert";
 import { convertReportCodeTypeObject, processModeConfigurations } from "./normalize-config.js";
 function defaultBoolean(v, dft) {
@@ -78,14 +78,25 @@ function normalizeUserConfig(config = {}) {
         ...config,
         output: outputConfig
     };
-    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = false, sdkInstance, innerClientPath = '', output = outputConfig, supports = getDefaultSupports(), port, printLog = {
+    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = false, sdkInstance, innerClientPath = '', output = outputConfig, supports: userSupports = {}, port, server: userServer = {}, printLog = {
         serverUrls: true
     }, mode, brief } = normalizedConfig;
+    const supports = {
+        ...getDefaultSupports(),
+        ...userSupports
+    };
     const disableClientServer = 'true' === process.env.RSTEST ? false : process.env.CI ? true : userDisableClientServer;
     assert('object' == typeof linter);
     assert('object' == typeof features || Array.isArray(features));
     assert('object' == typeof loaderInterceptorOptions);
     assert('boolean' == typeof disableClientServer);
+    assert(void 0 === port || 'number' == typeof port);
+    assert('object' == typeof userServer && null !== userServer);
+    const server = {
+        ...userServer
+    };
+    assert(void 0 === server.port || 'number' == typeof server.port);
+    if (void 0 === server.port && void 0 !== port) server.port = port;
     let finalMode = ('mode' in output && isValidMode(output.mode) ? 'lite' === output.mode ? SDK.IMode[SDK.IMode.normal] : output.mode : void 0) || mode || SDK.IMode[SDK.IMode.normal];
     if (mode) logger.info(chalk.yellow("The 'mode' configuration will be deprecated in a future version. Please use 'output.mode' instead."));
     const _features = normalizeFeatures(features, finalMode);
@@ -111,6 +122,7 @@ function normalizeUserConfig(config = {}) {
         innerClientPath,
         supports,
         port,
+        server,
         printLog
     };
     if (void 0 !== output.compressData) logger.info(chalk.yellow("The 'compressData' configuration will be deprecated in a future version."));
@@ -125,18 +137,5 @@ const normalizeReportType = (reportCodeType, mode)=>{
     if ('noModuleSource' === convertedReportCodeType) return SDK.ToDataType.NoSource;
     return SDK.ToDataType.Normal;
 };
-function normalizeRspackUserOptions(options) {
-    const config = normalizeUserConfig(options);
-    config.experiments ??= {
-        enableNativePlugin: {
-            moduleGraph: true,
-            chunkGraph: true
-        }
-    };
-    if ('boolean' == typeof options.experiments?.enableNativePlugin && options.experiments?.enableNativePlugin === false) config.experiments.enableNativePlugin = {
-        moduleGraph: false,
-        chunkGraph: false
-    };
-    return config;
-}
+const normalizeRspackUserOptions = normalizeUserConfig;
 export { normalizeReportType, normalizeRspackUserOptions, normalizeUserConfig };

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

@@ -1,13 +1,10 @@
-import { Loader } from '@rsdoctor/utils/common';
-import { SDK, Plugin } from '@rsdoctor/types';
+import { SDK, Plugin } from '@rsdoctor/shared/types';
 import { ProxyLoaderInternalOptions, ProxyLoaderOptions } from '../../types/index.js';
 import { Utils as BuildUtils } from '../../build-utils/build/index.js';
 export declare function getInternalLoaderOptions(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ProxyLoaderInternalOptions;
-export declare function getLoaderOptionsWithoutInternalKeys(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): Omit<ProxyLoaderOptions, typeof Loader.LoaderInternalPropertyName>;
+export declare function getLoaderOptionsWithoutInternalKeys(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): Record<string, any>;
 export declare function getOriginLoaderModule(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ReturnType<typeof BuildUtils.loadLoaderModule>;
 export declare function shouldSkipLoader(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): boolean;
-export type CompatibleResolve = Omit<Plugin.Configuration['resolve'], 'mainFields'> & {
-    mainFields?: string[];
-};
-export declare function interceptLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderPath: string, options: Omit<ProxyLoaderInternalOptions, 'loader' | 'hasOptions'>, cwd?: string, resolveLoader?: CompatibleResolve): T[];
+export type LoaderResolver = ReturnType<Plugin.BaseCompiler['resolverFactory']['get']>;
+export declare function interceptLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderPath: string, options: Omit<ProxyLoaderInternalOptions, 'loader' | 'hasOptions'>, loaderResolver: LoaderResolver, cwd?: string): T[];
 export declare function reportLoader(ctx: Plugin.LoaderContext<ProxyLoaderOptions>, start: number, startHRTime: [number, number], isPitch: boolean, sync: boolean, code: string, err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Plugin.SourceMapInput): Promise<SDK.LoaderData>;

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

@@ -1,11 +1,10 @@
 import "node:module";
-import { ResolverFactory } from "@rspack/resolver";
-import { omit } from "es-toolkit/compat";
+import { omit } from "../../collection.js";
 import path from "path";
-import { logger } from "@rsdoctor/utils/logger";
-import { Fetch, Loader, Lodash, Time } from "@rsdoctor/utils/common";
-import { SDK } from "@rsdoctor/types";
-import { DevToolError } from "@rsdoctor/utils/error";
+import { logger } from "../../logger.js";
+import { Fetch, Loader, Lodash, Time } from "../../common/index.js";
+import { SDK } from "@rsdoctor/shared/types";
+import { DevToolError } from "../../error/index.js";
 import { getSDK } from "./sdk.js";
 import { checkCirclePath } from "./circleDetect.js";
 import { Utils } from "../../build-utils/build/index.js";
@@ -40,36 +39,11 @@ function shouldSkipLoader(loaderContext) {
     }
     return false;
 }
-function interceptLoader(rules, loaderPath, options, cwd = process.cwd(), resolveLoader) {
-    const loaderResolver = new ResolverFactory({
-        conditionNames: [
-            'loader',
-            'require',
-            'node'
-        ],
-        exportsFields: [
-            'exports'
-        ],
-        mainFiles: [
-            'index'
-        ],
-        mainFields: [
-            'loader',
-            'main'
-        ],
-        extensions: [
-            'js',
-            '.json'
-        ],
-        modules: [
-            'node_modules'
-        ],
-        ...resolveLoader
-    });
+function interceptLoader(rules, loaderPath, options, loaderResolver, cwd = process.cwd()) {
     const resolve = (target)=>{
         try {
-            const result = loaderResolver.sync(cwd, target);
-            if (result.path) return result.path;
+            const result = loaderResolver.resolveSync({}, cwd, target);
+            if (result) return result;
         } catch  {}
         return target;
     };

package/dist/inner-plugins/utils/normalize-config.d.ts

@@ -1,4 +1,4 @@
-import { Config, Plugin, SDK } from '@rsdoctor/types';
+import { Config, Plugin, SDK } from '@rsdoctor/shared/types';
 import type { RuleSetCondition as RspackRuleSetCondition, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
 /**
  * Process mode-specific configurations with priority logic

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

@@ -0,0 +1 @@
+export declare function openBrowser(url: string, needEncodeURI?: boolean): Promise<boolean | undefined>;

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

@@ -0,0 +1,55 @@
+import "node:module";
+import { exec } from "node:child_process";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import { logger } from "../../logger.js";
+const execAsync = promisify(exec);
+const openBrowser_dirname = dirname(fileURLToPath(import.meta.url));
+const supportedChromiumBrowsers = [
+    'Google Chrome Canary',
+    'Google Chrome Dev',
+    'Google Chrome Beta',
+    'Google Chrome',
+    'Microsoft Edge',
+    'Brave Browser',
+    'Vivaldi',
+    'Chromium'
+];
+const getTargetBrowser = async ()=>{
+    let targetBrowser = process.env.BROWSER;
+    if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
+        const { stdout: ps } = await execAsync('ps cax');
+        targetBrowser = supportedChromiumBrowsers.find((b)=>ps.includes(b));
+    }
+    return targetBrowser;
+};
+const openWithDefaultBrowser = async (url)=>{
+    try {
+        const { default: open } = await import("open");
+        await open(url);
+        return true;
+    } catch (err) {
+        logger.error('Failed to open Rsdoctor URL.');
+        logger.error(err);
+        return false;
+    }
+};
+async function openBrowser(url, needEncodeURI = true) {
+    const shouldTryOpenChromeWithAppleScript = 'darwin' === process.platform;
+    if (shouldTryOpenChromeWithAppleScript) try {
+        const targetBrowser = await getTargetBrowser();
+        if (targetBrowser) {
+            await execAsync(`osascript openChrome.applescript "${needEncodeURI ? encodeURI(url) : url}" "${targetBrowser}"`, {
+                cwd: join(openBrowser_dirname, '../../../static')
+            });
+            return true;
+        }
+        logger.debug('Failed to find the target browser.');
+    } catch (err) {
+        logger.debug("Failed to open Rsdoctor URL with apple script.");
+        logger.debug(err);
+    }
+    return openWithDefaultBrowser(url);
+}
+export { openBrowser };

package/dist/inner-plugins/utils/plugin-common.js

@@ -1,9 +1,9 @@
 import "node:module";
-import { openBrowser } from "@rsdoctor/sdk";
-import { makeRulesSerializable } from "@rsdoctor/core/plugins";
-import { SDK } from "@rsdoctor/types";
-import { chalk } from "@rsdoctor/utils/logger";
+import { makeRulesSerializable } from "../index.js";
+import { SDK } from "@rsdoctor/shared/types";
+import { chalk } from "../../logger.js";
 import path from "path";
+import { openBrowser } from "./openBrowser.js";
 function safeCloneDeep(value, visited = new WeakMap()) {
     if (null == value) return value;
     if ('object' != typeof value) return value;

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

@@ -1,4 +1,4 @@
-import type { SDK } from '@rsdoctor/types';
+import type { SDK } from '@rsdoctor/shared/types';
 import { IHook } from '../../build-utils/build/utils/index.js';
 export declare function reportPluginData(sdk: SDK.RsdoctorBuilderSDKInstance, hook: string, tapName: string, start: number, type: SDK.PluginHookData['type'], _res: unknown, err?: Error): void;
 export declare function interceptPluginHook(sdk: SDK.RsdoctorBuilderSDKInstance, name: string, hook: IHook): void;

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

@@ -1,5 +1,5 @@
 import "node:module";
-import { DevToolError } from "@rsdoctor/utils/error";
+import { DevToolError } from "../../error/index.js";
 function reportPluginData(sdk, hook, tapName, start, type, _res, err) {
     const end = Date.now();
     sdk.reportPlugin({