@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/build-utils/build/utils/loader.js

@@ -1,22 +1,15 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import "node:module";
 import node_path from "node:path";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 import fs_extra from "fs-extra";
-import { omit } from "es-toolkit/compat";
-import { Loader } from "@rsdoctor/utils/common";
-import { readPackageJson } from "@rsdoctor/graph";
-import { logger } from "@rsdoctor/utils/logger";
-import { __webpack_require__ } from "../../../rslib-runtime.js";
-import { createRequire as __rspack_createRequire } from "node:module";
-const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
-__webpack_require__.add({
-    "module?2382" (module) {
-        module.exports = __rspack_createRequire_require("module");
-    }
-});
+import { omit } from "../../../collection.js";
+import { Loader } from "../../../common/index.js";
+import { readPackageJson } from "../json.js";
+import { logger } from "../../../logger.js";
 const loader_filename = fileURLToPath(import.meta.url);
 const loader_dirname = node_path.dirname(loader_filename);
+const loader_require = createRequire(import.meta.url);
 const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 function parsePathQueryFragment(str) {
     const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
@@ -28,9 +21,7 @@ function parsePathQueryFragment(str) {
 }
 function loadLoaderModule(loaderPath, cwd = process.cwd()) {
     const cleanLoaderPath = parsePathQueryFragment(loaderPath).path;
-    const { createRequire } = __webpack_require__("module?2382");
-    const requireFn = createRequire(import.meta.url);
-    const mod = requireFn(process.env.DOCTOR_TEST ? node_path.resolve(cwd, cleanLoaderPath) : requireFn.resolve(cleanLoaderPath, {
+    const mod = loader_require(process.env.DOCTOR_TEST ? node_path.resolve(cwd, cleanLoaderPath) : loader_require.resolve(cleanLoaderPath, {
         paths: [
             cwd,
             node_path.resolve(cwd, 'node_modules')
@@ -134,7 +125,7 @@ function appendProbeLoaders(compiler, loaderConfig) {
     const _options = 'object' == typeof loaderConfig ? 'string' == typeof loaderConfig.options ? {
         options: loaderConfig.options
     } : loaderConfig.options : {};
-    const loaderPath = process.env.DOCTOR_TEST ? node_path.resolve(loader_dirname, '../loader/probeLoader.ts') : require.resolve(node_path.join(loader_dirname, '../loader/probeLoader'));
+    const loaderPath = process.env.DOCTOR_TEST ? node_path.resolve(loader_dirname, '../loader/probeLoader.ts') : loader_require.resolve(node_path.join(loader_dirname, '../loader/probeLoader'));
     const loader = 'string' == typeof loaderConfig ? loaderConfig : 'object' == typeof loaderConfig && loaderConfig.loader;
     const createProbeLoader = (type)=>({
             loader: loaderPath,
@@ -228,7 +219,7 @@ function createLoaderContextTrap(final) {
                 case 'query':
                     if (target.query) {
                         if ('string' == typeof target.query) {
-                            const res = target.query.replace(new RegExp(`"${Loader.LoaderInternalPropertyName}":\{[^\}]*\},{0,1}`), '');
+                            const res = target.query.replace(new RegExp(`"${Loader.LoaderInternalPropertyName}":{[^}]*},{0,1}`), '');
                             return res;
                         }
                         if ('object' == typeof target.query) {

package/dist/build-utils/build/utils/parseBundle.d.ts

@@ -1,4 +1,4 @@
-import type { ParseBundle } from '@rsdoctor/graph';
+import type { ParseBundle } from '../../../graph/index.js';
 /**
  * The following code is based on
  * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/src/parseUtils.js#L10

package/dist/build-utils/build/utils/parseBundle.js

@@ -1,11 +1,11 @@
 import "node:module";
 import fs from "fs";
-import { find, mapValues } from "es-toolkit/compat";
+import { find, mapValues } from "../../../collection.js";
 import { filesize } from "filesize";
-import { parser } from "@rsdoctor/utils/ruleUtils";
+import { parser } from "../../../rule-utils/index.js";
 import { extname } from "path";
-import { Constants } from "@rsdoctor/types";
-import { logger } from "@rsdoctor/utils/logger";
+import { Constants } from "@rsdoctor/shared/types";
+import { logger } from "../../../logger.js";
 const parseBundle = (bundlePath, modulesData)=>{
     if (bundlePath.indexOf('.worker.') > 0) return {};
     const ext = extname(bundlePath);
@@ -20,7 +20,7 @@ const parseBundle = (bundlePath, modulesData)=>{
         content = tagMatchResult.result?.trim() || content;
         tagCache.set(bundlePath, tagMatchResult.loc);
         hasBannerPlugin = true;
-    } else if (hasBannerPlugin && !tagCache.get(bundlePath)) {
+    } else if (hasBannerPlugin && tagCache.get(bundlePath)) {
         const loc = tagCache.get(bundlePath);
         content = content.slice(loc.start, loc.end);
         hasBannerPlugin = true;
@@ -108,9 +108,7 @@ const parseBundle = (bundlePath, modulesData)=>{
         if (!module) return {};
         const moduleContent = modules[module];
         const size = moduleContent && Buffer.byteLength(moduleContent);
-        const identifier = find(modulesData, {
-            renderId: module
-        })?.webpackId || '';
+        const identifier = find(modulesData, (item)=>item.renderId === module)?.identifier || '';
         modulesObj[identifier] = {
             size,
             sizeConvert: filesize(size || 0),

package/dist/build-utils/build/utils/plugin.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import type { Plugin } from '@rsdoctor/shared/types';
 export type IHook = Plugin.BaseCompiler['hooks'][keyof Plugin.BaseCompiler['hooks']];
 export declare function shouldInterceptPluginHook<T extends IHook>(hook: T): boolean;
 export declare function interceptCompilerHooks(compiler: Plugin.BaseCompiler, interceptor: (name: string, hook: IHook, scope: 'compiler') => void): void;

package/dist/build-utils/build/utils/plugin.js

@@ -1,5 +1,4 @@
 import "node:module";
-import { ModuleGraphTrans } from "@rsdoctor/graph";
 function shouldInterceptPluginHook(hook) {
     if (hook && hook._fakeHook) return false;
     if (hook?.isUsed && 'function' == typeof hook.isUsed) return hook.isUsed();
@@ -14,7 +13,7 @@ function interceptCompilerHooks(compiler, interceptor) {
 }
 function interceptCompilationHooks(compilation, interceptor) {
     Object.keys(compilation.hooks).forEach((hook)=>{
-        if ('normalModuleLoader' === hook && ModuleGraphTrans.isWebpack5orRspack(compilation)) return;
+        if ('normalModuleLoader' === hook) return;
         const v = compilation.hooks[hook];
         if (shouldInterceptPluginHook(v)) interceptor(hook, v, 'compilation');
     });

package/dist/build-utils/index.d.ts

@@ -1 +1,11 @@
 export * as Build from './build/index.js';
+export * as EnvInfo from './build/envinfo.js';
+export * as File from './build/file/index.js';
+export * as Json from './build/json.js';
+export * as Process from './build/process.js';
+export * as Server from './build/server.js';
+export * as Chunks from './build/chunks/index.js';
+export * as Utils from './build/utils/index.js';
+export * as Loader from './build/loader/index.js';
+export * as Types from '../types/index.js';
+export * as ModuleGraph from './build/module-graph/index.js';

package/dist/build-utils/index.js

@@ -1,3 +1,13 @@
 import "node:module";
-import * as __rspack_external__build_index_js_0bf6183b from "./build/index.js";
-export { __rspack_external__build_index_js_0bf6183b as Build };
+import * as __rspack_external__build_index_js_dd3d3112 from "./build/index.js";
+import * as __rspack_external__build_envinfo_js_bb7cc383 from "./build/envinfo.js";
+import * as __rspack_external__build_file_index_js_b486e89f from "./build/file/index.js";
+import * as __rspack_external__build_json_js_4cd59ece from "./build/json.js";
+import * as __rspack_external__build_process_js_dbdc7299 from "./build/process.js";
+import * as __rspack_external__build_server_js_f760cf8d from "./build/server.js";
+import * as __rspack_external__build_chunks_index_js_b63f9e6b from "./build/chunks/index.js";
+import * as __rspack_external__build_utils_index_js_2ab2484c from "./build/utils/index.js";
+import * as __rspack_external__build_loader_index_js_a995ea1e from "./build/loader/index.js";
+import * as __rspack_external__types_index_js_b312a465 from "../types/index.js";
+import * as __rspack_external__build_module_graph_index_js_808da562 from "./build/module-graph/index.js";
+export { __rspack_external__build_chunks_index_js_b63f9e6b as Chunks, __rspack_external__build_envinfo_js_bb7cc383 as EnvInfo, __rspack_external__build_file_index_js_b486e89f as File, __rspack_external__build_index_js_dd3d3112 as Build, __rspack_external__build_json_js_4cd59ece as Json, __rspack_external__build_loader_index_js_a995ea1e as Loader, __rspack_external__build_module_graph_index_js_808da562 as ModuleGraph, __rspack_external__build_process_js_dbdc7299 as Process, __rspack_external__build_server_js_f760cf8d as Server, __rspack_external__build_utils_index_js_2ab2484c as Utils, __rspack_external__types_index_js_b312a465 as Types };

package/dist/collection.d.ts

@@ -0,0 +1 @@
+export * from '@rsdoctor/shared/collection';

package/dist/collection.js

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@rsdoctor/shared/collection";

package/dist/common/file.d.ts

@@ -0,0 +1,2 @@
+export declare function isStyleExt(path: string): boolean;
+export declare function isJsExt(path: string): boolean;

package/dist/common/file.js

@@ -0,0 +1,8 @@
+import "node:module";
+function isStyleExt(path) {
+    return /\.(c|le|sa|sc)ss(\?.*)?$/.test(path);
+}
+function isJsExt(path) {
+    return /\.(js|ts|jsx|tsx)(\?.*)?$/.test(path);
+}
+export { isJsExt, isStyleExt };

package/dist/common/global-config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @description Writes the builder port information to mcp.json.
+ *
+ * The mcp.json file uses the following format:
+ * {
+ *   portList: {
+ *     builder1: portNumber,
+ *     builder2: portNumber,
+ *   },
+ *   port: portNumber, // The port of the last builder is used by default
+ * }
+ *
+ * @param {number} port - The port number to write.
+ * @param {string} [builderName] - The name of the builder.
+ */
+export declare function writeMcpPort(port: number, builderName?: string): void;
+/**
+ * @description Gets the path to the mcp.json file.
+ * @returns {string} The path to the mcp.json file.
+ */
+export declare function getMcpConfigPath(): string;

package/dist/common/global-config.js

@@ -0,0 +1,33 @@
+import "node:module";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { logger } from "../logger.js";
+function writeMcpPort(port, builderName) {
+    const homeDir = os.homedir();
+    const rsdoctorDir = path.join(homeDir, '.cache/rsdoctor');
+    const mcpPortFilePath = path.join(rsdoctorDir, 'mcp.json');
+    if (!fs.existsSync(rsdoctorDir)) fs.mkdirSync(rsdoctorDir, {
+        recursive: true
+    });
+    let mcpJson = {
+        portList: {},
+        port: 0
+    };
+    if (fs.existsSync(mcpPortFilePath)) try {
+        mcpJson = JSON.parse(fs.readFileSync(mcpPortFilePath, 'utf8'));
+    } catch (error) {
+        logger.debug('Failed to parse mcp.json', error);
+    }
+    if (!mcpJson.portList) mcpJson.portList = {};
+    mcpJson.portList[builderName || 'builder'] = port;
+    mcpJson.port = port;
+    fs.writeFileSync(mcpPortFilePath, JSON.stringify(mcpJson, null, 2), 'utf8');
+}
+function getMcpConfigPath() {
+    const homeDir = os.homedir();
+    const rsdoctorDir = path.join(homeDir, '.cache/rsdoctor');
+    const mcpPortFilePath = path.join(rsdoctorDir, 'mcp.json');
+    return mcpPortFilePath;
+}
+export { getMcpConfigPath, writeMcpPort };

package/dist/common/index.d.ts

@@ -0,0 +1,4 @@
+export { Alerts, Algorithm, Bundle, Crypto, Data, Fetch, Graph, Loader, Lodash, Manifest, Package, Plugin, Resolver, Rspack, Summary, Time, Url, } from '@rsdoctor/shared/common-browser';
+export * as GlobalConfig from './global-config.js';
+export * as File from './file.js';
+export * from '@rsdoctor/shared/common-browser';

package/dist/common/index.js

@@ -0,0 +1,6 @@
+import "node:module";
+import * as __rspack_external__file_js_9fa33ca6 from "./file.js";
+import * as __rspack_external__global_config_js_a07079db from "./global-config.js";
+export * from "@rsdoctor/shared/common-browser";
+export { Alerts, Algorithm, Bundle, Crypto, Data, Fetch, Graph, Loader, Lodash, Manifest, Package, Plugin, Resolver, Rspack, Summary, Time, Url } from "@rsdoctor/shared/common-browser";
+export { __rspack_external__file_js_9fa33ca6 as File, __rspack_external__global_config_js_a07079db as GlobalConfig };

package/dist/common-browser.d.ts

@@ -0,0 +1 @@
+export * from '@rsdoctor/shared/common-browser';

package/dist/common-browser.js

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@rsdoctor/shared/common-browser";

package/dist/error/error.d.ts

@@ -0,0 +1,35 @@
+import { Err, Rule } from '@rsdoctor/shared/types';
+export declare class DevToolError extends Error implements Err.DevToolErrorInstance {
+    static from(err: unknown, opt?: Err.DevToolErrorParams): DevToolError;
+    readonly id: number;
+    readonly code?: string;
+    readonly category?: string;
+    readonly title: string;
+    readonly detail?: any;
+    readonly fixData?: Err.FixData;
+    readonly hint?: string;
+    readonly referenceUrl?: string;
+    private _codeFrame?;
+    private _controller;
+    private readonly _level;
+    constructor(title: string, message: string, opts?: Err.DevToolErrorParams);
+    get level(): keyof typeof Err.ErrorLevel;
+    get path(): string | undefined;
+    set path(file: string | undefined);
+    get codeFrame(): Err.CodeFrameOption | undefined;
+    private printCodeFrame;
+    toString(): string;
+    toData(): Rule.RuleStoreDataItem;
+    toError(): Error;
+    /**
+     * for json stringify
+     */
+    toJSON(): {
+        message: string;
+        name: string;
+        stack: string | undefined;
+    };
+    setControllerOption(opt: Err.ControllerOption): void;
+    setCodeFrame(opt: Err.CodeFrameOption): void;
+    isSame(error: Err.DevToolErrorInstance): boolean;
+}

package/dist/error/error.js

@@ -0,0 +1,143 @@
+import "node:module";
+import { codeFrameColumns } from "@babel/code-frame";
+import { Lodash } from "../common/index.js";
+import { Err } from "@rsdoctor/shared/types";
+import { createColors } from "picocolors";
+import deep_eql from "deep-eql";
+import strip_ansi from "strip-ansi";
+import { transform } from "./transform.js";
+import { insertSpace, toLevel } from "./utils.js";
+let id = 1;
+class DevToolError extends Error {
+    static from(err, opt) {
+        if (err instanceof DevToolError) return err;
+        return transform(err, opt);
+    }
+    get level() {
+        return Err.ErrorLevel[this._level];
+    }
+    get path() {
+        return this._codeFrame?.filePath;
+    }
+    set path(file) {
+        if (!file) return;
+        if (this._codeFrame) {
+            this._codeFrame.filePath = file;
+            return;
+        }
+        this._codeFrame = {
+            filePath: file
+        };
+    }
+    get codeFrame() {
+        return this._codeFrame;
+    }
+    printCodeFrame(print) {
+        const msgs = [];
+        const { _codeFrame: codeFrameOpt, _controller: controller } = this;
+        if (!codeFrameOpt) return msgs;
+        if ('start' in codeFrameOpt && codeFrameOpt.start) {
+            const { filePath, start } = codeFrameOpt;
+            msgs.push(`\n ${print.red(print.bold('File: '))}${print.bold(filePath)}:${start.line}${start.column ? `:${start.column}` : ''}`);
+            if ('fileContent' in codeFrameOpt) {
+                const { end, fileContent } = codeFrameOpt;
+                msgs.push(codeFrameColumns(fileContent, {
+                    start,
+                    end
+                }, {
+                    highlightCode: !controller.noColor
+                }));
+            } else if ('lineText' in codeFrameOpt) {
+                const { length, lineText } = codeFrameOpt;
+                let lineCodeFrame = codeFrameColumns(lineText, {
+                    start: {
+                        line: 1,
+                        column: start.column
+                    },
+                    end: {
+                        line: 1,
+                        column: Lodash.isNil(start.column) || Lodash.isNil(length) ? void 0 : start.column + length
+                    }
+                }, {
+                    highlightCode: !controller.noColor
+                });
+                if (start.line > 1) {
+                    lineCodeFrame = lineCodeFrame.replace(' 1 |', ` ${start.line} |`);
+                    if (start.line >= 10) lineCodeFrame = insertSpace(lineCodeFrame, 2, String(start.line).length - 1);
+                }
+                msgs.push(lineCodeFrame);
+            }
+        } else msgs.push(`\n ${print.red(print.bold('File: '))}${print.bold(codeFrameOpt.filePath)}\n`);
+        return msgs;
+    }
+    toString() {
+        const msgs = [];
+        const { code, title, message, hint, referenceUrl, _controller: controller } = this;
+        const print = createColors(!controller.noColor);
+        const mainColorPrint = this._level === Err.ErrorLevel.Error ? print.red : print.yellow;
+        const codeText = code ? `${mainColorPrint(print.blue(code))}:` : '';
+        msgs.push(mainColorPrint(print.bold(`[${codeText}${this.level}:${title.toUpperCase()}] `) + message));
+        msgs.push(...this.printCodeFrame(print));
+        if (hint || referenceUrl) msgs.push('');
+        if (hint) msgs.push(` ${print.blue(`HINT: ${hint}`)}`);
+        if (referenceUrl) msgs.push(print.magenta(print.bold(` See: ${referenceUrl}`)));
+        if (!controller.noStack && this.stack) msgs.push(print.red(print.bold(` Error Stack:\n${this.stack}\n`)));
+        return msgs.join('\n');
+    }
+    toData() {
+        return {
+            ...this.detail,
+            id: this.id,
+            category: this.category,
+            description: strip_ansi(this.detail?.description ?? this.message),
+            title: this.title.toUpperCase(),
+            code: this.code,
+            level: this.level.toLowerCase()
+        };
+    }
+    toError() {
+        const error = new Error();
+        error.message = this.toString();
+        error.name = this.name;
+        error.stack = this.stack;
+        return error;
+    }
+    toJSON() {
+        return {
+            message: this.toString(),
+            name: this.name,
+            stack: this.stack
+        };
+    }
+    setControllerOption(opt) {
+        this._controller = {
+            noStack: opt.noStack ?? this._controller.noStack ?? true,
+            noColor: opt.noColor ?? this._controller.noColor ?? false
+        };
+    }
+    setCodeFrame(opt) {
+        this._codeFrame = opt;
+    }
+    isSame(error) {
+        return this.code === error.code && this.message === error.message && this.hint === error.hint && this.level === error.level && this.title === error.title && this.referenceUrl === error.referenceUrl && this.code === error.code && deep_eql(this.codeFrame, error.codeFrame);
+    }
+    constructor(title, message, opts){
+        super(message), this._controller = {
+            noStack: true,
+            noColor: false
+        };
+        this.id = id++;
+        this.title = title;
+        this.code = opts?.code;
+        this.hint = opts?.hint;
+        this.stack = opts?.stack;
+        this.detail = opts?.detail;
+        this.fixData = opts?.fixData;
+        this.category = opts?.category;
+        this.referenceUrl = opts?.referenceUrl;
+        this._level = opts?.level ? toLevel(opts.level) : Err.ErrorLevel.Error;
+        this._codeFrame = opts?.codeFrame;
+        this.setControllerOption(opts?.controller ?? {});
+    }
+}
+export { DevToolError };

package/dist/error/index.d.ts

@@ -0,0 +1,2 @@
+export * from './error.js';
+export { printErrors } from './utils.js';

package/dist/error/index.js

@@ -0,0 +1,3 @@
+import "node:module";
+export * from "./error.js";
+export { printErrors } from "./utils.js";

package/dist/error/transform.d.ts

@@ -0,0 +1,3 @@
+import { Err } from '@rsdoctor/shared/types';
+import { DevToolError } from './error.js';
+export declare function transform(err: any, opt?: Err.DevToolErrorParams): DevToolError;

package/dist/error/transform.js

@@ -0,0 +1,138 @@
+import "node:module";
+import strip_ansi from "strip-ansi";
+import { Linter } from "@rsdoctor/shared/types";
+import { DevToolError } from "./error.js";
+const MAX_ERROR_MESSAGE_LENGTH = 1000;
+function truncateMessage(input, maxLen = MAX_ERROR_MESSAGE_LENGTH) {
+    const str = 'string' == typeof input ? input : String(input ?? '');
+    return str.length > maxLen ? str.slice(0, maxLen) : str;
+}
+function isEsbuildError(err) {
+    return 'pluginName' in err && 'text' in err && 'location' in err;
+}
+function isBabelError(err) {
+    return 'code' in err && 'reasonCode' in err;
+}
+function isDiagnosticError(err) {
+    return 'severity' in err && 'title' in err;
+}
+function parseBabelErrorMessage(input) {
+    const lines = strip_ansi(truncateMessage(input)).split('\n');
+    const filePath = lines[0].replace(/^([^:]+):.*/, '$1');
+    const message = lines[0].replace(/.*: (.*) \(\d+:\d+\)*/, '$1');
+    const lineText = lines.find((line)=>line.startsWith('> '))?.replace(/> \d+ \| /, '') ?? '';
+    return {
+        message,
+        filePath,
+        lineText
+    };
+}
+function clearMessage(str) {
+    return strip_ansi(truncateMessage(str)).replace(/.*: (.*)\n\n[\s\S]*/g, '$1');
+}
+function clearStack(str) {
+    return str.slice(str.indexOf('  at')).replace(/\s*at(.*) \((.*)\)/g, '$1\n$2\n');
+}
+function transformEsbuildError(err, opt) {
+    if (isEsbuildError(err)) {
+        const errorCode = opt?.code ?? 'ESBUILD_ERROR';
+        const speedyError = 'object' == typeof err.detail ? DevToolError.from(err.detail) : new DevToolError(errorCode, clearMessage(err.text), {
+            ...opt,
+            hint: err.location?.suggestion,
+            codeFrame: {
+                filePath: err.text.split(':')[0]
+            }
+        });
+        if (err.location) speedyError.setCodeFrame({
+            filePath: err.location.file,
+            lineText: err.location.lineText,
+            length: err.location.length,
+            start: {
+                line: err.location.line,
+                column: err.location.column + 1
+            }
+        });
+        return speedyError;
+    }
+}
+function transformBabelError(err, opt) {
+    if (isBabelError(err)) {
+        const errorCode = opt?.code ?? err.code ?? 'BABEL';
+        const title = err.reasonCode;
+        const errorParsed = parseBabelErrorMessage(err.message);
+        const speedyError = new DevToolError(title, truncateMessage(errorParsed.message), {
+            ...opt,
+            code: errorCode,
+            stack: err.stack && clearStack(err.stack)
+        });
+        if (err.loc) speedyError.setCodeFrame({
+            ...errorParsed,
+            start: {
+                line: err.loc.line,
+                column: err.loc.column + 1
+            }
+        });
+        return speedyError;
+    }
+}
+function transformNormalError(err, opt) {
+    if (err instanceof Error) {
+        const stacks = [];
+        const filePath = stacks?.[0]?.getFileName?.();
+        return new DevToolError(err.name, clearMessage(err.message), {
+            ...opt,
+            codeFrame: filePath ? {
+                filePath
+            } : void 0,
+            stack: err.stack && clearStack(err.stack)
+        });
+    }
+}
+function transformErrorLike(err, opt) {
+    const isErrorLike = err && 'object' == typeof err && err.message;
+    if (isErrorLike) {
+        const stacks = [];
+        const filePath = stacks?.[0]?.getFileName?.();
+        const message = truncateMessage(err.message);
+        return new DevToolError(err.name || 'UNKNOWN_ERROR', clearMessage(message), {
+            ...opt,
+            codeFrame: filePath ? {
+                filePath
+            } : void 0,
+            stack: err.stack && clearStack(err.stack)
+        });
+    }
+}
+function transformDiagnostic(err, opt) {
+    if (isDiagnosticError(err)) return new DevToolError(err.title, truncateMessage(err.message), {
+        ...err,
+        ...opt,
+        hint: err.suggestions?.description,
+        fixData: err.suggestions?.fixData,
+        codeFrame: err.document ? {
+            filePath: err.document.path,
+            fileContent: err.document.content,
+            start: err.document.range.start,
+            end: err.document.range.end
+        } : void 0,
+        level: Linter.Severity[err.severity]
+    });
+}
+function defaultError(err, opt) {
+    return new DevToolError('UNKNOWN_ERROR', JSON.stringify(err), opt);
+}
+function transform(err, opt) {
+    const transformers = [
+        transformEsbuildError,
+        transformBabelError,
+        transformDiagnostic,
+        transformNormalError,
+        transformErrorLike
+    ];
+    for (const fn of transformers){
+        const result = fn(err, opt);
+        if (result) return result;
+    }
+    return defaultError(err, opt);
+}
+export { transform };

package/dist/error/utils.d.ts

@@ -0,0 +1,4 @@
+import { Err, Logger } from '@rsdoctor/shared/types';
+export declare function toLevel(level: keyof typeof Err.ErrorLevel): Err.ErrorLevel;
+export declare function insertSpace(rawLines: string, line: number, width: number): string;
+export declare function printErrors({ errors, warnings }: Err.DevToolErrorsData, logLevel?: Logger.LogLevelName): string;

package/dist/error/utils.js

@@ -0,0 +1,23 @@
+import "node:module";
+import { Err } from "@rsdoctor/shared/types";
+function toLevel(level) {
+    return Err.ErrorLevel[level];
+}
+function insertSpace(rawLines, line, width) {
+    const lines = rawLines.split('\n');
+    lines[line - 1] = Array(width).fill(' ').join('') + lines[line - 1];
+    return lines.join('\n');
+}
+function printErrors({ errors, warnings }, logLevel = 'Error') {
+    const onlyError = 'Error' === logLevel;
+    if ('Silent' === logLevel) return '';
+    if (onlyError && 0 === errors.length || !onlyError && 0 === errors.length && 0 === warnings.length) return '';
+    const msgs = [];
+    if (onlyError) msgs.push(`Build failed with ${errors.length} error:`, ...errors.map((item)=>item.toString()), '');
+    else {
+        const title = 0 === errors.length ? `Build succuss with ${warnings.length} warning:` : `Build failed with ${errors.length} error, ${warnings.length} warning:`;
+        msgs.push(title, ...errors.map((item)=>item.toString()), ...warnings.map((item)=>item.toString()), '');
+    }
+    return msgs.join('\n\n');
+}
+export { insertSpace, printErrors, toLevel };

package/dist/graph/index.d.ts

@@ -0,0 +1 @@
+export * from '@rsdoctor/shared/graph';

package/dist/graph/index.js

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@rsdoctor/shared/graph";

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export * from './build-utils/index.js';
 export * as InnerPlugins from './inner-plugins/index.js';
+export { RsdoctorRspackPlugin } from './rspack-plugin/plugin.js';
+export { RsdoctorRspackMultiplePlugin } from './rspack-plugin/multiple.js';
 export * from './types/index.js';

package/dist/index.js

@@ -1,5 +1,7 @@
 import "node:module";
-import * as __rspack_external__inner_plugins_index_js_1dbd01aa from "./inner-plugins/index.js";
+import * as __rspack_external__inner_plugins_index_js_64c09f4a from "./inner-plugins/index.js";
 export * from "./build-utils/index.js";
 export * from "./types/index.js";
-export { __rspack_external__inner_plugins_index_js_1dbd01aa as InnerPlugins };
+export { RsdoctorRspackPlugin } from "./rspack-plugin/plugin.js";
+export { RsdoctorRspackMultiplePlugin } from "./rspack-plugin/multiple.js";
+export { __rspack_external__inner_plugins_index_js_64c09f4a as InnerPlugins };

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

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