@rsdoctor/core 1.2.3 → 1.2.4-beta.1

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

@@ -0,0 +1,166 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    calculateNamespaceAndRegex: ()=>calculateNamespaceAndRegex,
+    ensureDevtools: ()=>ensureDevtools,
+    ensureModulesChunksGraphFn: ()=>ensureModulesChunksGraphFn
+});
+const types_namespaceObject = require("@rsdoctor/types");
+const build_namespaceObject = require("@rsdoctor/utils/build");
+const logger_namespaceObject = require("@rsdoctor/utils/logger");
+const index_cjs_namespaceObject = require("../../build-utils/build/index.cjs");
+const external_constants_cjs_namespaceObject = require("../constants.cjs");
+const external_rspack_cjs_namespaceObject = require("./rspack.cjs");
+const external_sourcemapTool_cjs_namespaceObject = require("./sourcemapTool.cjs");
+let hasConsole = false;
+const ensureModulesChunksGraphFn = (compiler, _this)=>{
+    var _compiler_webpack_experiments;
+    if (_this._modulesGraphApplied) return;
+    _this._modulesGraphApplied = true;
+    const context = {
+        astCache: new Map(),
+        packagePathMap: new Map(),
+        getSourceMap: (file)=>_this.sdk.getSourceMap(file)
+    };
+    const RsdoctorRspackPlugin = null == (_compiler_webpack_experiments = compiler.webpack.experiments) ? void 0 : _compiler_webpack_experiments.RsdoctorPlugin;
+    if (RsdoctorRspackPlugin) (0, external_rspack_cjs_namespaceObject.applyRspackNativePlugin)(compiler, _this, RsdoctorRspackPlugin);
+    if (!_this._realSourcePathCache) _this._realSourcePathCache = new Map();
+    compiler.hooks.done.tapPromise((0, external_constants_cjs_namespaceObject.internalPluginTapPreOptions)('moduleGraph'), async (_stats)=>{
+        await doneHandler(_stats, _this, context, compiler);
+    });
+    compiler.hooks.afterEmit.tapPromise({
+        ...external_constants_cjs_namespaceObject.pluginTapPostOptions,
+        stage: external_constants_cjs_namespaceObject.pluginTapPostOptions.stage + 100
+    }, async (compilation)=>{
+        if (!ensureDevtools(compiler)) return;
+        const { namespace, sourceMapFilenameRegex } = calculateNamespaceAndRegex(compiler);
+        await (0, external_sourcemapTool_cjs_namespaceObject.handleAfterEmitAssets)(compilation, _this, sourceMapFilenameRegex, namespace);
+    });
+    compiler.hooks.emit.tapAsync({
+        ...external_constants_cjs_namespaceObject.pluginTapPostOptions,
+        stage: external_constants_cjs_namespaceObject.pluginTapPostOptions.stage + 100
+    }, emitHandler.bind(null, _this, compiler));
+};
+async function doneHandler(_stats, _this, context, compiler) {
+    var _this_chunkGraph;
+    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
+            });
+            return cached;
+        };
+    })();
+    logger_namespaceObject.logger.debug(`${(build_namespaceObject.Process.getMemoryUsageMessage(), '[Before Generate ModuleGraph]')}`);
+    if (!(null == (_this_chunkGraph = _this.chunkGraph) ? void 0 : _this_chunkGraph.getChunks().length)) _this.chunkGraph = index_cjs_namespaceObject.Chunks.chunkTransform(new Map(), getStatsJson());
+    if (!_this.modulesGraph.getModules().length) _this.modulesGraph = await index_cjs_namespaceObject.ModuleGraph.getModuleGraphByStats(stats.compilation, getStatsJson(), process.cwd(), _this.chunkGraph, _this.options.features, context);
+    logger_namespaceObject.logger.debug(`${(build_namespaceObject.Process.getMemoryUsageMessage(), '[After Generate ModuleGraph]')}`);
+    if (_this.options.features.treeShaking) {
+        if ('rspackVersion' in compiler.webpack) logger_namespaceObject.logger.info(logger_namespaceObject.chalk.yellow('Rspack currently does not support treeShaking capabilities.'));
+        else {
+            _this.modulesGraph = index_cjs_namespaceObject.ModuleGraph.appendTreeShaking(_this.modulesGraph, stats.compilation) || _this.modulesGraph;
+            _this.sdk.addClientRoutes([
+                types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.TreeShaking
+            ]);
+        }
+        logger_namespaceObject.logger.debug(`${(build_namespaceObject.Process.getMemoryUsageMessage(), '[After AppendTreeShaking to ModuleGraph]')}`);
+    }
+    const shouldParseBundle = false !== _this.options.supports.parseBundle;
+    await getModulesInfos(compiler, _this.modulesGraph, _this.chunkGraph, shouldParseBundle, _this.sourceMapSets);
+    logger_namespaceObject.logger.debug(`${build_namespaceObject.Process.getMemoryUsageMessage()}, '[After Transform ModuleGraph]'`);
+    _this.modulesGraph && await _this.sdk.reportModuleGraph(_this.modulesGraph);
+    await _this.sdk.reportChunkGraph(_this.chunkGraph);
+    if (_this.options.supports.generateTileGraph) logger_namespaceObject.logger.warn(logger_namespaceObject.chalk.yellow('The option generateTileGraph is deprecated. Treemap (i.e. Tile Graph) is now supported by default.'));
+}
+const ensureDevtools = (compiler)=>{
+    const devtool = compiler.options.devtool;
+    if ('string' == typeof devtool && /eval/i.test(devtool)) {
+        hasConsole || logger_namespaceObject.logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
+        hasConsole = true;
+        return false;
+    }
+    if ('rspack' in compiler) return true;
+    const sourceMapEnabled = 'string' == typeof devtool && /source-?map/i.test(devtool);
+    if (!sourceMapEnabled) {
+        logger_namespaceObject.logger.debug('SourceMap is not enabled. Skipping sourcemap processing.');
+        return false;
+    }
+    return true;
+};
+async function getModulesInfos(compiler, moduleGraph, chunkGraph, parseBundle, sourceMapSets) {
+    if (!moduleGraph) return;
+    try {
+        await index_cjs_namespaceObject.Chunks.getAssetsModulesData(moduleGraph, chunkGraph, compiler.outputPath, sourceMapSets, parseBundle);
+    } catch (e) {}
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function calculateNamespaceAndRegex(compiler) {
+    var _compiler_options_output_library;
+    let namespace = compiler.options.output.devtoolNamespace || (null == (_compiler_options_output_library = compiler.options.output.library) ? void 0 : _compiler_options_output_library.name) || '[^/]+/';
+    if (Array.isArray(namespace)) namespace = namespace[0];
+    else if ('object' == typeof namespace && 'name' in namespace) namespace = namespace.name;
+    const safeNamespace = escapeRegExp(namespace);
+    const sourceMapFilenameRegex = new RegExp(`(?:webpack://)?(?:${safeNamespace})?([^?]*)`);
+    return {
+        namespace: namespace,
+        sourceMapFilenameRegex
+    };
+}
+async function emitHandler(_this, compiler, compilation, callback) {
+    if (!ensureDevtools(compiler)) return void callback();
+    const { namespace, sourceMapFilenameRegex } = calculateNamespaceAndRegex(compiler);
+    await (0, external_sourcemapTool_cjs_namespaceObject.handleEmitAssets)({
+        compilation,
+        pluginInstance: _this,
+        sourceMapFilenameRegex,
+        namespace
+    });
+    callback();
+}
+exports.calculateNamespaceAndRegex = __webpack_exports__.calculateNamespaceAndRegex;
+exports.ensureDevtools = __webpack_exports__.ensureDevtools;
+exports.ensureModulesChunksGraphFn = __webpack_exports__.ensureModulesChunksGraphFn;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "calculateNamespaceAndRegex",
+    "ensureDevtools",
+    "ensureModulesChunksGraphFn"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -34,4 +34,3 @@ export declare function calculateNamespaceAndRegex(compiler: Plugin.BaseCompiler
     namespace: string;
     sourceMapFilenameRegex: RegExp;
 };
-//# sourceMappingURL=ensureModulesChunkGraph.d.ts.map

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

@@ -1,40 +1,12 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    calculateNamespaceAndRegex: ()=>calculateNamespaceAndRegex,
-    ensureDevtools: ()=>ensureDevtools,
-    ensureModulesChunksGraphFn: ()=>ensureModulesChunksGraphFn
-});
-const types_namespaceObject = require("@rsdoctor/types");
-const build_namespaceObject = require("@rsdoctor/utils/build");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
-const index_js_namespaceObject = require("../../build-utils/build/index.js");
-const external_constants_js_namespaceObject = require("../constants.js");
-const external_rspack_js_namespaceObject = require("./rspack.js");
-const external_sourcemapTool_js_namespaceObject = require("./sourcemapTool.js");
+import 'module';
+/*#__PURE__*/ import.meta.url;
+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 { internalPluginTapPreOptions, pluginTapPostOptions } from "../constants.js";
+import { applyRspackNativePlugin } from "./rspack.js";
+import { handleAfterEmitAssets, handleEmitAssets } from "./sourcemapTool.js";
 let hasConsole = false;
 const ensureModulesChunksGraphFn = (compiler, _this)=>{
     var _compiler_webpack_experiments;
@@ -46,22 +18,22 @@ const ensureModulesChunksGraphFn = (compiler, _this)=>{
         getSourceMap: (file)=>_this.sdk.getSourceMap(file)
     };
     const RsdoctorRspackPlugin = null == (_compiler_webpack_experiments = compiler.webpack.experiments) ? void 0 : _compiler_webpack_experiments.RsdoctorPlugin;
-    if (RsdoctorRspackPlugin) (0, external_rspack_js_namespaceObject.applyRspackNativePlugin)(compiler, _this, RsdoctorRspackPlugin);
+    if (RsdoctorRspackPlugin) applyRspackNativePlugin(compiler, _this, RsdoctorRspackPlugin);
     if (!_this._realSourcePathCache) _this._realSourcePathCache = new Map();
-    compiler.hooks.done.tapPromise((0, external_constants_js_namespaceObject.internalPluginTapPreOptions)('moduleGraph'), async (_stats)=>{
+    compiler.hooks.done.tapPromise(internalPluginTapPreOptions('moduleGraph'), async (_stats)=>{
         await doneHandler(_stats, _this, context, compiler);
     });
     compiler.hooks.afterEmit.tapPromise({
-        ...external_constants_js_namespaceObject.pluginTapPostOptions,
-        stage: external_constants_js_namespaceObject.pluginTapPostOptions.stage + 100
+        ...pluginTapPostOptions,
+        stage: pluginTapPostOptions.stage + 100
     }, async (compilation)=>{
         if (!ensureDevtools(compiler)) return;
         const { namespace, sourceMapFilenameRegex } = calculateNamespaceAndRegex(compiler);
-        await (0, external_sourcemapTool_js_namespaceObject.handleAfterEmitAssets)(compilation, _this, sourceMapFilenameRegex, namespace);
+        await handleAfterEmitAssets(compilation, _this, sourceMapFilenameRegex, namespace);
     });
     compiler.hooks.emit.tapAsync({
-        ...external_constants_js_namespaceObject.pluginTapPostOptions,
-        stage: external_constants_js_namespaceObject.pluginTapPostOptions.stage + 100
+        ...pluginTapPostOptions,
+        stage: pluginTapPostOptions.stage + 100
     }, emitHandler.bind(null, _this, compiler));
 };
 async function doneHandler(_stats, _this, context, compiler) {
@@ -71,42 +43,52 @@ async function doneHandler(_stats, _this, context, compiler) {
         let cached = null;
         return ()=>{
             if (cached) return cached;
-            cached = stats.toJson();
+            cached = stats.toJson({
+                all: false,
+                chunks: true,
+                modules: true,
+                chunkModules: true,
+                assets: true,
+                ids: true,
+                hash: true,
+                errors: true,
+                warnings: true
+            });
             return cached;
         };
     })();
-    logger_namespaceObject.logger.debug(`${(build_namespaceObject.Process.getMemoryUsageMessage(), '[Before Generate ModuleGraph]')}`);
-    if (!(null == (_this_chunkGraph = _this.chunkGraph) ? void 0 : _this_chunkGraph.getChunks().length)) _this.chunkGraph = index_js_namespaceObject.Chunks.chunkTransform(new Map(), getStatsJson());
-    if (!_this.modulesGraph.getModules().length) _this.modulesGraph = await index_js_namespaceObject.ModuleGraph.getModuleGraphByStats(stats.compilation, getStatsJson(), process.cwd(), _this.chunkGraph, _this.options.features, context);
-    logger_namespaceObject.logger.debug(`${(build_namespaceObject.Process.getMemoryUsageMessage(), '[After Generate ModuleGraph]')}`);
+    logger.debug(`${(Process.getMemoryUsageMessage(), '[Before Generate ModuleGraph]')}`);
+    if (!(null == (_this_chunkGraph = _this.chunkGraph) ? void 0 : _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_namespaceObject.logger.info(logger_namespaceObject.chalk.yellow('Rspack currently does not support treeShaking capabilities.'));
+        if ('rspackVersion' in compiler.webpack) logger.info(chalk.yellow('Rspack currently does not support treeShaking capabilities.'));
         else {
-            _this.modulesGraph = index_js_namespaceObject.ModuleGraph.appendTreeShaking(_this.modulesGraph, stats.compilation) || _this.modulesGraph;
+            _this.modulesGraph = ModuleGraph.appendTreeShaking(_this.modulesGraph, stats.compilation) || _this.modulesGraph;
             _this.sdk.addClientRoutes([
-                types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.TreeShaking
+                Manifest.RsdoctorManifestClientRoutes.TreeShaking
             ]);
         }
-        logger_namespaceObject.logger.debug(`${(build_namespaceObject.Process.getMemoryUsageMessage(), '[After AppendTreeShaking to ModuleGraph]')}`);
+        logger.debug(`${(Process.getMemoryUsageMessage(), '[After AppendTreeShaking to ModuleGraph]')}`);
     }
     const shouldParseBundle = false !== _this.options.supports.parseBundle;
     await getModulesInfos(compiler, _this.modulesGraph, _this.chunkGraph, shouldParseBundle, _this.sourceMapSets);
-    logger_namespaceObject.logger.debug(`${build_namespaceObject.Process.getMemoryUsageMessage()}, '[After Transform ModuleGraph]'`);
+    logger.debug(`${Process.getMemoryUsageMessage()}, '[After Transform ModuleGraph]'`);
     _this.modulesGraph && await _this.sdk.reportModuleGraph(_this.modulesGraph);
     await _this.sdk.reportChunkGraph(_this.chunkGraph);
-    if (_this.options.supports.generateTileGraph) logger_namespaceObject.logger.warn(logger_namespaceObject.chalk.yellow('The option generateTileGraph is deprecated. Treemap (i.e. Tile Graph) is now supported by default.'));
+    if (_this.options.supports.generateTileGraph) logger.warn(chalk.yellow('The option generateTileGraph is deprecated. Treemap (i.e. Tile Graph) is now supported by default.'));
 }
 const ensureDevtools = (compiler)=>{
     const devtool = compiler.options.devtool;
     if ('string' == typeof devtool && /eval/i.test(devtool)) {
-        hasConsole || logger_namespaceObject.logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
+        hasConsole || logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
         hasConsole = true;
         return false;
     }
     if ('rspack' in compiler) return true;
     const sourceMapEnabled = 'string' == typeof devtool && /source-?map/i.test(devtool);
     if (!sourceMapEnabled) {
-        logger_namespaceObject.logger.debug('SourceMap is not enabled. Skipping sourcemap processing.');
+        logger.debug('SourceMap is not enabled. Skipping sourcemap processing.');
         return false;
     }
     return true;
@@ -114,7 +96,7 @@ const ensureDevtools = (compiler)=>{
 async function getModulesInfos(compiler, moduleGraph, chunkGraph, parseBundle, sourceMapSets) {
     if (!moduleGraph) return;
     try {
-        await index_js_namespaceObject.Chunks.getAssetsModulesData(moduleGraph, chunkGraph, compiler.outputPath, sourceMapSets, parseBundle);
+        await Chunks.getAssetsModulesData(moduleGraph, chunkGraph, compiler.outputPath, sourceMapSets, parseBundle);
     } catch (e) {}
 }
 function escapeRegExp(str) {
@@ -135,7 +117,7 @@ function calculateNamespaceAndRegex(compiler) {
 async function emitHandler(_this, compiler, compilation, callback) {
     if (!ensureDevtools(compiler)) return void callback();
     const { namespace, sourceMapFilenameRegex } = calculateNamespaceAndRegex(compiler);
-    await (0, external_sourcemapTool_js_namespaceObject.handleEmitAssets)({
+    await handleEmitAssets({
         compilation,
         pluginInstance: _this,
         sourceMapFilenameRegex,
@@ -143,14 +125,4 @@ async function emitHandler(_this, compiler, compilation, callback) {
     });
     callback();
 }
-exports.calculateNamespaceAndRegex = __webpack_exports__.calculateNamespaceAndRegex;
-exports.ensureDevtools = __webpack_exports__.ensureDevtools;
-exports.ensureModulesChunksGraphFn = __webpack_exports__.ensureModulesChunksGraphFn;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "calculateNamespaceAndRegex",
-    "ensureDevtools",
-    "ensureModulesChunksGraphFn"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { calculateNamespaceAndRegex, ensureDevtools, ensureModulesChunksGraphFn };

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

@@ -0,0 +1,98 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    InternalErrorReporterPlugin: ()=>InternalErrorReporterPlugin
+});
+const types_namespaceObject = require("@rsdoctor/types");
+const external_base_cjs_namespaceObject = require("./base.cjs");
+const error_namespaceObject = require("@rsdoctor/utils/error");
+const logger_namespaceObject = require("@rsdoctor/utils/logger");
+class InternalErrorReporterPlugin extends external_base_cjs_namespaceObject.InternalBasePlugin {
+    apply(compiler) {
+        (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.apply');
+        try {
+            compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
+        } finally{
+            (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.apply');
+        }
+    }
+    handleWebpackError(err, category, level) {
+        return error_namespaceObject.DevToolError.from(err, {
+            category,
+            code: types_namespaceObject.Rule.RuleMessageCodeEnumerated.Overlay,
+            controller: {
+                noStack: false
+            },
+            detail: {
+                stack: 'stack' in err ? err.stack : err.message
+            },
+            level
+        });
+    }
+    async reportWarnings(warnings) {
+        (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.reportWarnings');
+        try {
+            const arr = warnings.map((warning)=>this.handleWebpackError(warning, types_namespaceObject.Rule.RuleMessageCategory.Compile, 'Warn'));
+            this.sdk.reportError(arr);
+        } finally{
+            (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.reportWarnings');
+        }
+    }
+    async reportErrors(errors) {
+        (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.reportErrors');
+        try {
+            const arr = errors.map((err)=>this.handleWebpackError(err, types_namespaceObject.Rule.RuleMessageCategory.Bundle, 'Error'));
+            this.sdk.reportError(arr);
+        } finally{
+            (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.reportErrors');
+        }
+    }
+    constructor(...args){
+        super(...args), this.name = 'error-reporter', this.done = async (stats)=>{
+            (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.done');
+            try {
+                const tasks = [];
+                const statsData = stats.toJson({
+                    all: false,
+                    errors: true,
+                    warnings: true
+                });
+                if (stats.hasErrors()) tasks.push(this.reportErrors(statsData.errors || []));
+                if (stats.hasWarnings()) tasks.push(this.reportWarnings(statsData.warnings || []));
+                await Promise.all(tasks);
+            } finally{
+                (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.done');
+            }
+        };
+    }
+}
+exports.InternalErrorReporterPlugin = __webpack_exports__.InternalErrorReporterPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "InternalErrorReporterPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -9,4 +9,3 @@ export declare class InternalErrorReporterPlugin<T extends Plugin.BaseCompiler>
     reportWarnings(warnings: Plugin.BuildError[]): Promise<void>;
     reportErrors(errors: Plugin.BuildWarning[]): Promise<void>;
 }
-//# sourceMappingURL=errors.d.ts.map

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

@@ -1,48 +1,22 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    InternalErrorReporterPlugin: ()=>InternalErrorReporterPlugin
-});
-const types_namespaceObject = require("@rsdoctor/types");
-const external_base_js_namespaceObject = require("./base.js");
-const error_namespaceObject = require("@rsdoctor/utils/error");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
-class InternalErrorReporterPlugin extends external_base_js_namespaceObject.InternalBasePlugin {
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { Rule } from "@rsdoctor/types";
+import { InternalBasePlugin } from "./base.js";
+import { DevToolError } from "@rsdoctor/utils/error";
+import { time, timeEnd } from "@rsdoctor/utils/logger";
+class InternalErrorReporterPlugin extends InternalBasePlugin {
     apply(compiler) {
-        (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.apply');
+        time('InternalErrorReporterPlugin.apply');
         try {
             compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
         } finally{
-            (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.apply');
+            timeEnd('InternalErrorReporterPlugin.apply');
         }
     }
     handleWebpackError(err, category, level) {
-        return error_namespaceObject.DevToolError.from(err, {
+        return DevToolError.from(err, {
             category,
-            code: types_namespaceObject.Rule.RuleMessageCodeEnumerated.Overlay,
+            code: Rule.RuleMessageCodeEnumerated.Overlay,
             controller: {
                 noStack: false
             },
@@ -53,26 +27,26 @@ class InternalErrorReporterPlugin extends external_base_js_namespaceObject.Inter
         });
     }
     async reportWarnings(warnings) {
-        (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.reportWarnings');
+        time('InternalErrorReporterPlugin.reportWarnings');
         try {
-            const arr = warnings.map((warning)=>this.handleWebpackError(warning, types_namespaceObject.Rule.RuleMessageCategory.Compile, 'Warn'));
+            const arr = warnings.map((warning)=>this.handleWebpackError(warning, Rule.RuleMessageCategory.Compile, 'Warn'));
             this.sdk.reportError(arr);
         } finally{
-            (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.reportWarnings');
+            timeEnd('InternalErrorReporterPlugin.reportWarnings');
         }
     }
     async reportErrors(errors) {
-        (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.reportErrors');
+        time('InternalErrorReporterPlugin.reportErrors');
         try {
-            const arr = errors.map((err)=>this.handleWebpackError(err, types_namespaceObject.Rule.RuleMessageCategory.Bundle, 'Error'));
+            const arr = errors.map((err)=>this.handleWebpackError(err, Rule.RuleMessageCategory.Bundle, 'Error'));
             this.sdk.reportError(arr);
         } finally{
-            (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.reportErrors');
+            timeEnd('InternalErrorReporterPlugin.reportErrors');
         }
     }
     constructor(...args){
         super(...args), this.name = 'error-reporter', this.done = async (stats)=>{
-            (0, logger_namespaceObject.time)('InternalErrorReporterPlugin.done');
+            time('InternalErrorReporterPlugin.done');
             try {
                 const tasks = [];
                 const statsData = stats.toJson({
@@ -84,15 +58,9 @@ class InternalErrorReporterPlugin extends external_base_js_namespaceObject.Inter
                 if (stats.hasWarnings()) tasks.push(this.reportWarnings(statsData.warnings || []));
                 await Promise.all(tasks);
             } finally{
-                (0, logger_namespaceObject.timeEnd)('InternalErrorReporterPlugin.done');
+                timeEnd('InternalErrorReporterPlugin.done');
             }
         };
     }
 }
-exports.InternalErrorReporterPlugin = __webpack_exports__.InternalErrorReporterPlugin;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "InternalErrorReporterPlugin"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { InternalErrorReporterPlugin };