@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

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';
-export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorWebpackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
+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) {
@@ -22,7 +22,6 @@ function getDefaultOutput() {
 function getDefaultSupports() {
     return {
         parseBundle: true,
-        banner: void 0,
         gzip: true
     };
 }
@@ -96,6 +95,7 @@ function normalizeUserConfig(config = {}) {
     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."));
@@ -137,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;
     };
@@ -149,10 +123,10 @@ async function reportLoader(ctx, start, startHRTime, isPitch, sync, code, err, r
     }
     await Promise.all([
         Fetch.postJSON(`${host}${SDK.ServerAPI.API.ReportLoader}`, loaderData, 8888).catch((err)=>{
-            logger.debug(`${err.message}`, '[WebpackPlugin.ReportLoader][error]');
+            logger.debug(`${err.message}`, '[RspackPlugin.ReportLoader][error]');
         }),
         Fetch.postJSON(`${host}${SDK.ServerAPI.API.ReportSourceMap}`, sourceMapData, 8888).catch((err)=>{
-            logger.debug(`${err.message}`, '[WebpackPlugin.ReportSourceMap][error]');
+            logger.debug(`${err.message}`, '[RspackPlugin.ReportSourceMap][error]');
         })
     ]);
     return loaderData;

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

@@ -1,6 +1,5 @@
-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';
-import { RuleSetCondition as WebpackRuleSetCondition, RuleSetConditionAbsolute as WebpackRuleSetConditionAbsolute, RuleSetRule as WebpackRuleSetRule } from 'webpack';
 /**
  * Process mode-specific configurations with priority logic
  */
@@ -22,9 +21,7 @@ export declare function convertReportCodeTypeObject(reportCodeType: any): Config
  * properly serialized to JSON.
  *
  * @param item - The rule set condition to make serializable. Can be:
- *   - RspackRuleSetCondition: Rspack-specific rule conditions
- *   - WebpackRuleSetConditionAbsolute: Webpack absolute rule conditions
- *   - WebpackRuleSetCondition: Webpack rule conditions
+ *   - RspackRuleSetCondition: Rspack rule conditions
  *   - void: Undefined or null values
  *
  * @example
@@ -36,5 +33,5 @@ export declare function convertReportCodeTypeObject(reportCodeType: any): Config
  * JSON.stringify(condition); // '"/\\.js$/"'
  * ```
  */
-export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | WebpackRuleSetConditionAbsolute | WebpackRuleSetCondition | void): void;
-export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf'] | WebpackRuleSetRule['oneOf']): void;
+export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | void): void;
+export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf']): void;

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({

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

@@ -1,8 +1,7 @@
-import { RsdoctorPrimarySDK } from '@rsdoctor/sdk';
-import { SDK } from '@rsdoctor/types';
+import { SDK } from '@rsdoctor/shared/types';
 declare global {
     var __rsdoctor_sdks__: SDK.RsdoctorBuilderSDKInstance[] | undefined;
     var __rsdoctor_sdk__: SDK.RsdoctorBuilderSDKInstance | undefined;
 }
 export declare function setSDK(t: SDK.RsdoctorBuilderSDKInstance): void;
-export declare function getSDK(builderName?: string): RsdoctorPrimarySDK | SDK.RsdoctorBuilderSDKInstance | undefined;
+export declare function getSDK(builderName?: string): SDK.RsdoctorBuilderSDKInstance | undefined;

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

@@ -10,8 +10,8 @@ function getSDK(builderName) {
     let sdk = globalThis['__rsdoctor_sdk__'];
     if (sdk && sdk.name !== builderName) sdk = builderName ? sdks.find((s)=>s.name === builderName) || sdk : sdk;
     if (sdk && builderName && 'parent' in sdk) {
-        const _sdk = sdk;
-        const slaveSDK = _sdk.parent.slaves.find((_sdk)=>_sdk.name === builderName);
+        const parent = sdk.parent;
+        const slaveSDK = parent?.slaves.find((_sdk)=>_sdk.name === builderName);
         return slaveSDK || sdk;
     }
     return sdk;

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+import c from 'picocolors';
+/**
+ * log debug message
+ */
+export declare function debug(getMsg: () => string, prefix?: string): void;
+declare const rsdoctorLogger: import("rslog").Logger;
+declare function time(label: string): void;
+declare function timeEnd(label: string): void;
+export { time, timeEnd, c as chalk, rsdoctorLogger as logger };

package/dist/logger.js

@@ -0,0 +1,51 @@
+import "node:module";
+import picocolors from "picocolors";
+import { createLogger, logger } from "rslog";
+import { Constants } from "@rsdoctor/shared/types";
+function debug(getMsg, prefix = '') {
+    if (!process.env.DEBUG) return;
+    logger.level = 'verbose';
+    logger.debug(`${prefix} ${getMsg()}`);
+}
+const rsdoctorLogger = createLogger();
+rsdoctorLogger.override({
+    log: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR LOG]')} ${message}`);
+    },
+    info: (message)=>{
+        console.log(`${picocolors.yellow('[RSDOCTOR INFO]')} ${message}`);
+    },
+    warn: (message)=>{
+        console.warn(`${picocolors.yellow('[RSDOCTOR WARN]')} ${message}`);
+    },
+    start: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR START]')} ${message}`);
+    },
+    ready: (message)=>{
+        console.log(`${picocolors.green('[RSDOCTOR READY]')} ${message}`);
+    },
+    error: (message)=>{
+        console.error(`${picocolors.red('[RSDOCTOR ERROR]')} ${message}`);
+    },
+    success: (message)=>{
+        console.error(`${picocolors.green('[RSDOCTOR SUCCESS]')} ${message}`);
+    },
+    debug: (message)=>{
+        if (process.env.DEBUG) console.log(`${picocolors.blue('[RSDOCTOR DEBUG]')} ${message}`);
+    }
+});
+const _timers = new Map();
+function time(label) {
+    if (process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey) return;
+    if (_timers.has(label)) return;
+    _timers.set(label, Date.now());
+}
+function timeEnd(label) {
+    if (process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey) return;
+    const start = _timers.get(label);
+    if (null == start) return void logger.debug(`Timer '${label}' does not exist.`);
+    const duration = Date.now() - start;
+    logger.debug(`Timer '${label}' ended: ${duration}ms`);
+    _timers.delete(label);
+}
+export { debug, picocolors as chalk, rsdoctorLogger as logger, time, timeEnd };

package/dist/{inner-plugins/constants.d.cts → rspack-plugin/constants.d.ts}

@@ -1,6 +1,9 @@
 import type { Tap } from 'tapable';
-export declare const pluginTapName = "RsdoctorWebpackPlugin";
+export declare const pluginTapName = "RsdoctorRspackPlugin";
 export declare const pluginTapPostOptions: Tap;
 export declare const pluginTapPreOptions: Tap;
 export declare const internalPluginTapPreOptions: (namespace: string) => Tap;
 export declare const internalPluginTapPostOptions: (namespace: string) => Tap;
+export declare const pkg: {
+    version: string;
+};

package/dist/rspack-plugin/constants.js

@@ -0,0 +1,23 @@
+import "node:module";
+import { createRequire } from "node:module";
+const constants_require = createRequire(import.meta.url);
+const packageJson = constants_require('../../package.json');
+const pluginTapName = 'RsdoctorRspackPlugin';
+const pluginTapPostOptions = {
+    name: pluginTapName,
+    stage: 999
+};
+const pluginTapPreOptions = {
+    name: pluginTapName,
+    stage: -999
+};
+const internalPluginTapPreOptions = (namespace)=>({
+        name: `${pluginTapName}:${namespace}`,
+        stage: -998
+    });
+const internalPluginTapPostOptions = (namespace)=>({
+        name: `${pluginTapName}:${namespace}`,
+        stage: 1000
+    });
+const pkg = packageJson;
+export { internalPluginTapPostOptions, internalPluginTapPreOptions, pkg, pluginTapName, pluginTapPostOptions, pluginTapPreOptions };

package/dist/rspack-plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from './plugin.js';
+export * from './multiple.js';

package/dist/rspack-plugin/index.js

@@ -0,0 +1,3 @@
+import "node:module";
+export * from "./plugin.js";
+export * from "./multiple.js";

package/dist/rspack-plugin/multiple.d.ts

@@ -0,0 +1,8 @@
+import type { RsdoctorMultiplePluginOptions } from '../types/index.js';
+import { type Linter, type Plugin } from '@rsdoctor/shared/types';
+import { RsdoctorRspackPlugin } from './plugin.js';
+export declare class RsdoctorRspackMultiplePlugin<Rules extends Linter.ExtendRuleData[]> extends RsdoctorRspackPlugin<Rules> {
+    private controller;
+    constructor(options?: RsdoctorMultiplePluginOptions<Rules>);
+    apply(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+}

package/dist/rspack-plugin/multiple.js

@@ -0,0 +1,39 @@
+import "node:module";
+import { RsdoctorSDKController } from "../sdk.js";
+import { SDK } from "@rsdoctor/shared/types";
+import { normalizeUserConfig } from "../inner-plugins/index.js";
+import { RsdoctorRspackPlugin } from "./plugin.js";
+let globalController;
+class RsdoctorRspackMultiplePlugin extends RsdoctorRspackPlugin {
+    apply(compiler) {
+        if ('dependencies' in compiler.options) this.sdk.dependencies = compiler.options.dependencies;
+        super.apply(compiler);
+    }
+    constructor(options = {}){
+        const controller = (()=>{
+            if (globalController) return globalController;
+            const controller = new RsdoctorSDKController();
+            globalController = controller;
+            return controller;
+        })();
+        const normallizedOptions = normalizeUserConfig(options);
+        const instance = controller.createSlave({
+            name: options.name || 'Builder',
+            stage: options.stage,
+            extraConfig: {
+                innerClientPath: normallizedOptions.innerClientPath,
+                printLog: normallizedOptions.printLog,
+                server: normallizedOptions.server,
+                mode: normallizedOptions.output.mode ? normallizedOptions.output.mode : void 0,
+                brief: normallizedOptions.output.mode === SDK.IMode[SDK.IMode.brief] ? normallizedOptions.output.options || void 0 : void 0
+            },
+            type: normallizedOptions.output.reportCodeType
+        });
+        super({
+            ...options,
+            sdkInstance: instance
+        });
+        this.controller = controller;
+    }
+}
+export { RsdoctorRspackMultiplePlugin };

package/dist/rspack-plugin/plugin.d.ts

@@ -0,0 +1,25 @@
+import type { RsdoctorRspackPluginInstance, RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../types/index.js';
+import { RsdoctorPrimarySDK } from '../sdk/index.js';
+import { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
+export declare class RsdoctorRspackPlugin<Rules extends Linter.ExtendRuleData[]> implements RsdoctorRspackPluginInstance<Rules> {
+    readonly name = "RsdoctorRspackPlugin";
+    readonly sdk: SDK.RsdoctorBuilderSDKInstance | RsdoctorPrimarySDK;
+    readonly isRsdoctorPlugin: boolean;
+    _bootstrapTask: Promise<unknown>;
+    protected browserIsOpened: boolean;
+    modulesGraph: SDK.ModuleGraphInstance;
+    options: RsdoctorRspackPluginOptionsNormalized<Rules>;
+    outsideInstance: boolean;
+    constructor(options?: RsdoctorRspackPluginOptions<Rules>);
+    apply(compiler: unknown): unknown;
+    /**
+     * @description Generate ModuleGraph and ChunkGraph from the Rspack native plugin.
+     * @param {Compiler} compiler
+     * @return {*}
+     * @memberof RsdoctorRspackPlugin
+     */
+    ensureModulesChunksGraphApplied(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+    afterPlugins: (compiler: Plugin.BaseCompilerType<'rspack'>) => void;
+    done: (compiler: Plugin.BaseCompilerType<'rspack'>) => Promise<void>;
+    getRspackConfig(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+}

package/dist/rspack-plugin/plugin.js

@@ -0,0 +1,133 @@
+import "node:module";
+import { Loader } from "../build-utils/index.js";
+import { InternalBundlePlugin, InternalErrorReporterPlugin, InternalLoaderPlugin, InternalPluginsPlugin, InternalResolverPlugin, InternalRulesPlugin, InternalSummaryPlugin, ensureModulesChunksGraphFn, handleBriefModeReport, normalizeRspackUserOptions, processCompilerConfig, setSDK } from "../inner-plugins/index.js";
+import { RsdoctorSDK, findRoot } from "../sdk.js";
+import { Constants, Manifest, SDK } from "@rsdoctor/shared/types";
+import path from "path";
+import { pkg, pluginTapName, pluginTapPostOptions } from "./constants.js";
+import { ModuleGraph } from "../graph/index.js";
+import { Loader as index_js_Loader } from "../common/index.js";
+import { logger, time, timeEnd } from "../logger.js";
+import { getRspackNativePlugin } from "../inner-plugins/plugins/rspack.js";
+let hasGreeted = false;
+class RsdoctorRspackPlugin {
+    apply(compiler) {
+        time('RsdoctorRspackPlugin.apply');
+        try {
+            if (!hasGreeted && !compiler.isChild()) {
+                hasGreeted = true;
+                logger.greet(`
+        \nRsdoctor v${pkg.version}\n`);
+            }
+            if (!this._bootstrapTask) this._bootstrapTask = this.sdk.bootstrap();
+            if (compiler.options.name) this.sdk.setName(compiler.options.name);
+            setSDK(this.sdk);
+            compiler.hooks.afterPlugins.tap(pluginTapPostOptions, this.afterPlugins.bind(this, compiler));
+            compiler.hooks.done.tapPromise({
+                ...pluginTapPostOptions,
+                stage: pluginTapPostOptions.stage + 100
+            }, this.done.bind(this, compiler));
+            new InternalSummaryPlugin(this).apply(compiler);
+            if (this.options.features.loader) {
+                new Loader.ProbeLoaderPlugin().apply(compiler);
+                this.sdk.addClientRoutes([
+                    Manifest.RsdoctorManifestClientRoutes.Loaders
+                ]);
+                if (!index_js_Loader.isVue(compiler)) new InternalLoaderPlugin(this).apply(compiler);
+            }
+            if (this.options.features.plugins) new InternalPluginsPlugin(this).apply(compiler);
+            if (this.options.features.bundle) new InternalBundlePlugin(this).apply(compiler);
+            if (this.options.features.resolver) new InternalResolverPlugin(this).apply(compiler);
+            new InternalRulesPlugin(this).apply(compiler);
+            new InternalErrorReporterPlugin(this).apply(compiler);
+            const RsdoctorRspackNativePlugin = getRspackNativePlugin(compiler);
+            logger.debug('[RspackNativePlugin] Enabled');
+            new RsdoctorRspackNativePlugin({
+                moduleGraphFeatures: true,
+                chunkGraphFeatures: true,
+                sourceMapFeatures: {
+                    cheap: false,
+                    module: false
+                }
+            }).apply(compiler);
+        } finally{
+            timeEnd('RsdoctorRspackPlugin.apply');
+        }
+    }
+    ensureModulesChunksGraphApplied(compiler) {
+        ensureModulesChunksGraphFn(compiler, this);
+    }
+    getRspackConfig(compiler) {
+        time('RsdoctorRspackPlugin.getRspackConfig');
+        try {
+            if (compiler.isChild()) return;
+            const configuration = processCompilerConfig(compiler.options);
+            const rspackVersion = compiler.webpack?.rspackVersion || compiler.webpack?.version;
+            this.sdk.reportConfiguration({
+                name: 'rspack',
+                version: rspackVersion || 'unknown',
+                config: configuration,
+                root: findRoot() || ''
+            });
+        } finally{
+            timeEnd('RsdoctorRspackPlugin.getRspackConfig');
+        }
+    }
+    constructor(options){
+        this.name = pluginTapName;
+        this.browserIsOpened = false;
+        this.afterPlugins = (compiler)=>{
+            time('RsdoctorRspackPlugin.afterPlugins');
+            try {
+                this.getRspackConfig(compiler);
+            } finally{
+                timeEnd('RsdoctorRspackPlugin.afterPlugins');
+            }
+        };
+        this.done = async (compiler)=>{
+            time('RsdoctorRspackPlugin.done');
+            try {
+                logger.debug('[RsdoctorRspackPlugin] bootstrap(start) in done()');
+                await this.sdk.bootstrap();
+                logger.debug('[RsdoctorRspackPlugin] bootstrap(end) in done()');
+                this.sdk.addClientRoutes([
+                    Manifest.RsdoctorManifestClientRoutes.Overall
+                ]);
+                if (this.outsideInstance && 'parent' in this.sdk) this.sdk.parent.master.setOutputDir(path.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`));
+                this.sdk.setOutputDir(path.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`));
+                await this.sdk.writeStore();
+                if (!this.options.disableClientServer) if (this.options.output.mode === SDK.IMode[SDK.IMode.brief]) await handleBriefModeReport(this.sdk, this.options, this.options.disableClientServer);
+                else await this.sdk.server.openClientPage('homepage');
+                if (this.options.disableClientServer || this.options.output.mode === SDK.IMode[SDK.IMode.brief] && Array.isArray(this.options.output.options?.type) && 1 === this.options.output.options.type.length && 'json' === this.options.output.options.type[0]) await this.sdk.dispose();
+            } finally{
+                timeEnd('RsdoctorRspackPlugin.done');
+            }
+        };
+        this.options = normalizeRspackUserOptions(Object.assign(options || {}, {
+            supports: {
+                ...options?.supports
+            }
+        }));
+        const { port, server, output, innerClientPath, printLog, sdkInstance } = this.options;
+        this.sdk = this.options.sdkInstance ?? new RsdoctorSDK({
+            port,
+            name: pluginTapName,
+            root: process.cwd(),
+            type: output.reportCodeType,
+            config: {
+                innerClientPath,
+                printLog,
+                server,
+                mode: output.mode ? output.mode : void 0,
+                brief: output.mode === SDK.IMode[SDK.IMode.brief] ? output.options || void 0 : void 0,
+                features: {
+                    treeShaking: this.options.features.treeShaking
+                }
+            }
+        });
+        this.outsideInstance = Boolean(sdkInstance);
+        this.modulesGraph = new ModuleGraph();
+        this.isRsdoctorPlugin = true;
+    }
+}
+export { RsdoctorRspackPlugin };

package/dist/rule-utils/document/document.d.ts

@@ -0,0 +1,16 @@
+import { Range, OffsetRange, Position, DocumentEditData } from './types.js';
+/** Document Catalogue */
+export declare class Document {
+    /** Actual document content. */
+    private _text;
+    /** Get the displacement of the file position in the text. */
+    positionAt: (offset: number) => Position | undefined;
+    /** Get the position of the displacement point in the file. */
+    offsetAt: (position: Position) => number | undefined;
+    constructor(content: string);
+    /** Generate location search */
+    private createFinder;
+    getText(range?: Range | OffsetRange): string;
+    /** Edit document data */
+    edit(data: DocumentEditData): string | undefined;
+}