@rsdoctor/core 1.2.3 → 1.2.4-beta.1

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

@@ -0,0 +1,73 @@
+"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__, {
+    InternalPluginsPlugin: ()=>InternalPluginsPlugin
+});
+const types_namespaceObject = require("@rsdoctor/types");
+const index_cjs_namespaceObject = require("../../build-utils/build/index.cjs");
+const external_utils_index_cjs_namespaceObject = require("../utils/index.cjs");
+const external_base_cjs_namespaceObject = require("./base.cjs");
+const logger_namespaceObject = require("@rsdoctor/utils/logger");
+class InternalPluginsPlugin extends external_base_cjs_namespaceObject.InternalBasePlugin {
+    apply(compiler) {
+        (0, logger_namespaceObject.time)('InternalPluginsPlugin.apply');
+        try {
+            compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler));
+            compiler.hooks.compilation.tap(this.tapPostOptions, this.compilation);
+        } finally{
+            (0, logger_namespaceObject.timeEnd)('InternalPluginsPlugin.apply');
+        }
+    }
+    constructor(...args){
+        super(...args), this.name = 'plugins', this.afterPlugins = (compiler)=>{
+            (0, logger_namespaceObject.time)('InternalPluginsPlugin.afterPlugins');
+            try {
+                if (compiler.isChild()) return;
+                index_cjs_namespaceObject.Utils.interceptCompilerHooks(compiler, (name, hook)=>(0, external_utils_index_cjs_namespaceObject.interceptPluginHook)(this.sdk, name, hook));
+                this.sdk.addClientRoutes([
+                    types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.WebpackPlugins
+                ]);
+            } finally{
+                (0, logger_namespaceObject.timeEnd)('InternalPluginsPlugin.afterPlugins');
+            }
+        }, this.compilation = (compilation)=>{
+            (0, logger_namespaceObject.time)('InternalPluginsPlugin.compilation');
+            try {
+                if (compilation.compiler.isChild()) return;
+                index_cjs_namespaceObject.Utils.interceptCompilationHooks(compilation, (name, hook)=>(0, external_utils_index_cjs_namespaceObject.interceptPluginHook)(this.sdk, name, hook));
+            } finally{
+                (0, logger_namespaceObject.timeEnd)('InternalPluginsPlugin.compilation');
+            }
+        };
+    }
+}
+exports.InternalPluginsPlugin = __webpack_exports__.InternalPluginsPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "InternalPluginsPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -6,4 +6,3 @@ export declare class InternalPluginsPlugin<T extends Plugin.BaseCompiler> extend
     afterPlugins: (compiler: Plugin.BaseCompiler) => void;
     compilation: (compilation: Plugin.BaseCompilation) => void;
 }
-//# sourceMappingURL=plugins.d.ts.map

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

@@ -1,73 +1,41 @@
-"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__, {
-    InternalPluginsPlugin: ()=>InternalPluginsPlugin
-});
-const types_namespaceObject = require("@rsdoctor/types");
-const index_js_namespaceObject = require("../../build-utils/build/index.js");
-const external_utils_index_js_namespaceObject = require("../utils/index.js");
-const external_base_js_namespaceObject = require("./base.js");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
-class InternalPluginsPlugin extends external_base_js_namespaceObject.InternalBasePlugin {
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { Manifest } from "@rsdoctor/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";
+class InternalPluginsPlugin extends InternalBasePlugin {
     apply(compiler) {
-        (0, logger_namespaceObject.time)('InternalPluginsPlugin.apply');
+        time('InternalPluginsPlugin.apply');
         try {
             compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler));
             compiler.hooks.compilation.tap(this.tapPostOptions, this.compilation);
         } finally{
-            (0, logger_namespaceObject.timeEnd)('InternalPluginsPlugin.apply');
+            timeEnd('InternalPluginsPlugin.apply');
         }
     }
     constructor(...args){
         super(...args), this.name = 'plugins', this.afterPlugins = (compiler)=>{
-            (0, logger_namespaceObject.time)('InternalPluginsPlugin.afterPlugins');
+            time('InternalPluginsPlugin.afterPlugins');
             try {
                 if (compiler.isChild()) return;
-                index_js_namespaceObject.Utils.interceptCompilerHooks(compiler, (name, hook)=>(0, external_utils_index_js_namespaceObject.interceptPluginHook)(this.sdk, name, hook));
+                Utils.interceptCompilerHooks(compiler, (name, hook)=>interceptPluginHook(this.sdk, name, hook));
                 this.sdk.addClientRoutes([
-                    types_namespaceObject.Manifest.RsdoctorManifestClientRoutes.WebpackPlugins
+                    Manifest.RsdoctorManifestClientRoutes.WebpackPlugins
                 ]);
             } finally{
-                (0, logger_namespaceObject.timeEnd)('InternalPluginsPlugin.afterPlugins');
+                timeEnd('InternalPluginsPlugin.afterPlugins');
             }
         }, this.compilation = (compilation)=>{
-            (0, logger_namespaceObject.time)('InternalPluginsPlugin.compilation');
+            time('InternalPluginsPlugin.compilation');
             try {
                 if (compilation.compiler.isChild()) return;
-                index_js_namespaceObject.Utils.interceptCompilationHooks(compilation, (name, hook)=>(0, external_utils_index_js_namespaceObject.interceptPluginHook)(this.sdk, name, hook));
+                Utils.interceptCompilationHooks(compilation, (name, hook)=>interceptPluginHook(this.sdk, name, hook));
             } finally{
-                (0, logger_namespaceObject.timeEnd)('InternalPluginsPlugin.compilation');
+                timeEnd('InternalPluginsPlugin.compilation');
             }
         };
     }
 }
-exports.InternalPluginsPlugin = __webpack_exports__.InternalPluginsPlugin;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "InternalPluginsPlugin"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { InternalPluginsPlugin };

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

@@ -0,0 +1,70 @@
+"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__, {
+    InternalProgressPlugin: ()=>InternalProgressPlugin
+});
+const types_namespaceObject = require("@rsdoctor/types");
+const external_base_cjs_namespaceObject = require("./base.cjs");
+const logger_namespaceObject = require("@rsdoctor/utils/logger");
+class InternalProgressPlugin extends external_base_cjs_namespaceObject.InternalBasePlugin {
+    apply(compiler) {
+        const { sdk, currentProgress } = this;
+        if (compiler.webpack && compiler.webpack.ProgressPlugin) {
+            const progress = new compiler.webpack.ProgressPlugin({
+                handler (percentage, msg) {
+                    currentProgress.percentage = percentage;
+                    currentProgress.message = msg || '';
+                    const api = types_namespaceObject.SDK.ServerAPI.APIExtends.GetCompileProgress;
+                    try {
+                        sdk.server.sendAPIDataToClient(api, {
+                            req: {
+                                api,
+                                body: void 0
+                            },
+                            res: currentProgress
+                        });
+                    } catch (e) {
+                        logger_namespaceObject.logger.debug(e);
+                    }
+                }
+            });
+            progress.apply(compiler);
+        }
+    }
+    constructor(...args){
+        super(...args), this.name = 'progress', this.currentProgress = {
+            percentage: 100,
+            message: ''
+        };
+    }
+}
+exports.InternalProgressPlugin = __webpack_exports__.InternalProgressPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "InternalProgressPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -6,4 +6,3 @@ export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'w
     protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgress>;
     apply(compiler: T): void;
 }
-//# sourceMappingURL=progress.d.ts.map

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

@@ -1,35 +1,9 @@
-"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__, {
-    InternalProgressPlugin: ()=>InternalProgressPlugin
-});
-const types_namespaceObject = require("@rsdoctor/types");
-const external_base_js_namespaceObject = require("./base.js");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
-class InternalProgressPlugin extends external_base_js_namespaceObject.InternalBasePlugin {
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { SDK } from "@rsdoctor/types";
+import { InternalBasePlugin } from "./base.js";
+import { logger } from "@rsdoctor/utils/logger";
+class InternalProgressPlugin extends InternalBasePlugin {
     apply(compiler) {
         const { sdk, currentProgress } = this;
         if (compiler.webpack && compiler.webpack.ProgressPlugin) {
@@ -37,7 +11,7 @@ class InternalProgressPlugin extends external_base_js_namespaceObject.InternalBa
                 handler (percentage, msg) {
                     currentProgress.percentage = percentage;
                     currentProgress.message = msg || '';
-                    const api = types_namespaceObject.SDK.ServerAPI.APIExtends.GetCompileProgress;
+                    const api = SDK.ServerAPI.APIExtends.GetCompileProgress;
                     try {
                         sdk.server.sendAPIDataToClient(api, {
                             req: {
@@ -47,7 +21,7 @@ class InternalProgressPlugin extends external_base_js_namespaceObject.InternalBa
                             res: currentProgress
                         });
                     } catch (e) {
-                        logger_namespaceObject.logger.debug(e);
+                        logger.debug(e);
                     }
                 }
             });
@@ -61,10 +35,4 @@ class InternalProgressPlugin extends external_base_js_namespaceObject.InternalBa
         };
     }
 }
-exports.InternalProgressPlugin = __webpack_exports__.InternalProgressPlugin;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "InternalProgressPlugin"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { InternalProgressPlugin };

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

@@ -0,0 +1,117 @@
+"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__, {
+    applyRspackNativePlugin: ()=>applyRspackNativePlugin
+});
+const graph_namespaceObject = require("@rsdoctor/graph");
+const index_cjs_namespaceObject = require("../../build-utils/build/index.cjs");
+const external_constants_cjs_namespaceObject = require("../constants.cjs");
+const logger_namespaceObject = require("@rsdoctor/utils/logger");
+function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
+    logger_namespaceObject.logger.debug('[RspackNativePlugin] Apply hooks');
+    compiler.hooks.compilation.tap('RsdoctorRspackPlugin', (compilation)=>{
+        const hooks = RsdoctorRspackPlugin.getCompilationHooks(compilation);
+        const cached = {};
+        const dependOn = {
+            chunkGraphData: [],
+            moduleGraphData: [
+                'chunkGraphData'
+            ],
+            assetPatchData: [
+                'chunkGraphData'
+            ],
+            moduleIdsPatchData: [
+                'moduleGraphData'
+            ],
+            moduleSourcesPatchData: [
+                'moduleGraphData'
+            ]
+        };
+        const consumer = {
+            chunkGraphData: (data)=>{
+                plugin.chunkGraph = new graph_namespaceObject.ChunkGraph();
+                index_cjs_namespaceObject.Chunks.patchNativeChunkGraph(plugin.chunkGraph, data);
+            },
+            moduleGraphData: (data)=>{
+                index_cjs_namespaceObject.ModuleGraph.patchNativeModuleGraph(plugin.modulesGraph, plugin.chunkGraph, data);
+            },
+            moduleIdsPatchData: (data)=>{
+                index_cjs_namespaceObject.ModuleGraph.patchNativeModuleIds(plugin.modulesGraph, data);
+            },
+            moduleSourcesPatchData: (data)=>{
+                index_cjs_namespaceObject.ModuleGraph.patchNativeModuleSources(plugin.modulesGraph, data);
+            },
+            assetPatchData: (data)=>{
+                index_cjs_namespaceObject.Chunks.patchNativeAssets(plugin.chunkGraph, data);
+            }
+        };
+        const tryConsumeData = (key, data)=>{
+            if (true === cached[key]) return;
+            cached[key] = data;
+            while(true){
+                let hasConsumed = false;
+                for (const [_task, deps] of Object.entries(dependOn)){
+                    const task = _task;
+                    if (true === cached[task] || void 0 === cached[task]) continue;
+                    const prepared = deps.every((dep)=>true === cached[dep]);
+                    if (prepared) {
+                        consumer[task](cached[task]);
+                        cached[task] = true;
+                        hasConsumed = true;
+                    }
+                }
+                if (!hasConsumed) break;
+            }
+        };
+        hooks.chunkGraph.tap((0, external_constants_cjs_namespaceObject.internalPluginTapPreOptions)('nativeChunkGraph'), (rawChunkGraph)=>{
+            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called chunkGraph hook');
+            tryConsumeData('chunkGraphData', rawChunkGraph);
+        });
+        hooks.moduleGraph.tap((0, external_constants_cjs_namespaceObject.internalPluginTapPreOptions)('nativeModuleGraph'), (rawModuleGraph)=>{
+            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called moduleGraph hook');
+            tryConsumeData('moduleGraphData', rawModuleGraph);
+        });
+        hooks.moduleIds.tap((0, external_constants_cjs_namespaceObject.internalPluginTapPreOptions)('nativeSourcePatch'), (rawModuleIdsPatch)=>{
+            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called moduleIds hook');
+            tryConsumeData('moduleIdsPatchData', rawModuleIdsPatch);
+        });
+        hooks.moduleSources.tap((0, external_constants_cjs_namespaceObject.internalPluginTapPreOptions)('nativeModuleSourcesPatch'), (rawModuleSourcesPatch)=>{
+            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called moduleSources hook');
+            tryConsumeData('moduleSourcesPatchData', rawModuleSourcesPatch);
+        });
+        hooks.assets.tap((0, external_constants_cjs_namespaceObject.internalPluginTapPreOptions)('nativeAssetPatch'), (rawAssetPatch)=>{
+            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called assets hook');
+            tryConsumeData('assetPatchData', rawAssetPatch);
+        });
+    });
+}
+exports.applyRspackNativePlugin = __webpack_exports__.applyRspackNativePlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "applyRspackNativePlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -2,4 +2,3 @@ import { Linter, Plugin } from '@rsdoctor/types';
 import type { experiments } from '@rspack/core';
 import { RsdoctorPluginInstance } from '../../types';
 export declare function applyRspackNativePlugin(compiler: Plugin.BaseCompiler, plugin: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>, RsdoctorRspackPlugin: typeof experiments.RsdoctorPlugin): void;
-//# sourceMappingURL=rspack.d.ts.map

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

@@ -1,37 +1,11 @@
-"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__, {
-    applyRspackNativePlugin: ()=>applyRspackNativePlugin
-});
-const graph_namespaceObject = require("@rsdoctor/graph");
-const index_js_namespaceObject = require("../../build-utils/build/index.js");
-const external_constants_js_namespaceObject = require("../constants.js");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { ChunkGraph } from "@rsdoctor/graph";
+import { Chunks, ModuleGraph } from "../../build-utils/build/index.js";
+import { internalPluginTapPreOptions } from "../constants.js";
+import { logger } from "@rsdoctor/utils/logger";
 function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
-    logger_namespaceObject.logger.debug('[RspackNativePlugin] Apply hooks');
+    logger.debug('[RspackNativePlugin] Apply hooks');
     compiler.hooks.compilation.tap('RsdoctorRspackPlugin', (compilation)=>{
         const hooks = RsdoctorRspackPlugin.getCompilationHooks(compilation);
         const cached = {};
@@ -52,20 +26,20 @@ function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
         };
         const consumer = {
             chunkGraphData: (data)=>{
-                plugin.chunkGraph = new graph_namespaceObject.ChunkGraph();
-                index_js_namespaceObject.Chunks.patchNativeChunkGraph(plugin.chunkGraph, data);
+                plugin.chunkGraph = new ChunkGraph();
+                Chunks.patchNativeChunkGraph(plugin.chunkGraph, data);
             },
             moduleGraphData: (data)=>{
-                index_js_namespaceObject.ModuleGraph.patchNativeModuleGraph(plugin.modulesGraph, plugin.chunkGraph, data);
+                ModuleGraph.patchNativeModuleGraph(plugin.modulesGraph, plugin.chunkGraph, data);
             },
             moduleIdsPatchData: (data)=>{
-                index_js_namespaceObject.ModuleGraph.patchNativeModuleIds(plugin.modulesGraph, data);
+                ModuleGraph.patchNativeModuleIds(plugin.modulesGraph, data);
             },
             moduleSourcesPatchData: (data)=>{
-                index_js_namespaceObject.ModuleGraph.patchNativeModuleSources(plugin.modulesGraph, data);
+                ModuleGraph.patchNativeModuleSources(plugin.modulesGraph, data);
             },
             assetPatchData: (data)=>{
-                index_js_namespaceObject.Chunks.patchNativeAssets(plugin.chunkGraph, data);
+                Chunks.patchNativeAssets(plugin.chunkGraph, data);
             }
         };
         const tryConsumeData = (key, data)=>{
@@ -86,32 +60,26 @@ function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
                 if (!hasConsumed) break;
             }
         };
-        hooks.chunkGraph.tap((0, external_constants_js_namespaceObject.internalPluginTapPreOptions)('nativeChunkGraph'), (rawChunkGraph)=>{
-            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called chunkGraph hook');
+        hooks.chunkGraph.tap(internalPluginTapPreOptions('nativeChunkGraph'), (rawChunkGraph)=>{
+            logger.debug('[RspackNativePlugin] Called chunkGraph hook');
             tryConsumeData('chunkGraphData', rawChunkGraph);
         });
-        hooks.moduleGraph.tap((0, external_constants_js_namespaceObject.internalPluginTapPreOptions)('nativeModuleGraph'), (rawModuleGraph)=>{
-            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called moduleGraph hook');
+        hooks.moduleGraph.tap(internalPluginTapPreOptions('nativeModuleGraph'), (rawModuleGraph)=>{
+            logger.debug('[RspackNativePlugin] Called moduleGraph hook');
             tryConsumeData('moduleGraphData', rawModuleGraph);
         });
-        hooks.moduleIds.tap((0, external_constants_js_namespaceObject.internalPluginTapPreOptions)('nativeSourcePatch'), (rawModuleIdsPatch)=>{
-            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called moduleIds hook');
+        hooks.moduleIds.tap(internalPluginTapPreOptions('nativeSourcePatch'), (rawModuleIdsPatch)=>{
+            logger.debug('[RspackNativePlugin] Called moduleIds hook');
             tryConsumeData('moduleIdsPatchData', rawModuleIdsPatch);
         });
-        hooks.moduleSources.tap((0, external_constants_js_namespaceObject.internalPluginTapPreOptions)('nativeModuleSourcesPatch'), (rawModuleSourcesPatch)=>{
-            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called moduleSources hook');
+        hooks.moduleSources.tap(internalPluginTapPreOptions('nativeModuleSourcesPatch'), (rawModuleSourcesPatch)=>{
+            logger.debug('[RspackNativePlugin] Called moduleSources hook');
             tryConsumeData('moduleSourcesPatchData', rawModuleSourcesPatch);
         });
-        hooks.assets.tap((0, external_constants_js_namespaceObject.internalPluginTapPreOptions)('nativeAssetPatch'), (rawAssetPatch)=>{
-            logger_namespaceObject.logger.debug('[RspackNativePlugin] Called assets hook');
+        hooks.assets.tap(internalPluginTapPreOptions('nativeAssetPatch'), (rawAssetPatch)=>{
+            logger.debug('[RspackNativePlugin] Called assets hook');
             tryConsumeData('assetPatchData', rawAssetPatch);
         });
     });
 }
-exports.applyRspackNativePlugin = __webpack_exports__.applyRspackNativePlugin;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "applyRspackNativePlugin"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { applyRspackNativePlugin };

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

@@ -0,0 +1,97 @@
+"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__, {
+    InternalRulesPlugin: ()=>InternalRulesPlugin
+});
+const external_base_cjs_namespaceObject = require("./base.cjs");
+const index_cjs_namespaceObject = require("../../rules/index.cjs");
+const error_namespaceObject = require("@rsdoctor/utils/error");
+const external_lodash_es_namespaceObject = require("lodash-es");
+const logger_namespaceObject = require("@rsdoctor/utils/logger");
+class InternalRulesPlugin extends external_base_cjs_namespaceObject.InternalBasePlugin {
+    apply(compiler) {
+        (0, logger_namespaceObject.time)('InternalRulesPlugin.apply');
+        try {
+            compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
+        } finally{
+            (0, logger_namespaceObject.timeEnd)('InternalRulesPlugin.apply');
+        }
+    }
+    async lint(compilation) {
+        (0, logger_namespaceObject.time)('InternalRulesPlugin.lint');
+        try {
+            const options = this.options ?? {};
+            const linter = new index_cjs_namespaceObject.Linter(options.linter);
+            const result = await linter.validate(this.sdk.getRuleContext({}));
+            const validateErrors = result.errors.map((err)=>error_namespaceObject.DevToolError.from(err, {
+                    detail: err.detail,
+                    controller: {
+                        noColor: true
+                    }
+                }));
+            const errors = validateErrors.filter((item)=>'Error' === item.level);
+            const warnings = validateErrors.filter((item)=>'Warn' === item.level);
+            const toWebpackError = (err)=>err.toError();
+            result.replace.forEach((item)=>{
+                if (Array.isArray(compilation.errors) && compilation.errors.includes(item)) (0, external_lodash_es_namespaceObject.pull)(compilation.errors, item);
+                if (Array.isArray(compilation.warnings) && compilation.warnings.includes(item)) (0, external_lodash_es_namespaceObject.pull)(compilation.warnings, item);
+            });
+            if (Array.isArray(compilation.errors)) errors.forEach((err)=>{
+                compilation.warnings.push(toWebpackError(err));
+            });
+            if (Array.isArray(compilation.warnings)) warnings.forEach((err)=>{
+                compilation.warnings.push(toWebpackError(err));
+            });
+            this.sdk.reportError(validateErrors);
+            await linter.afterValidate({
+                data: this.sdk.getRuleContext({}),
+                validateResult: result,
+                hooks: {
+                    afterSaveManifest: this.sdk.hooks.afterSaveManifest
+                }
+            });
+        } finally{
+            (0, logger_namespaceObject.timeEnd)('InternalRulesPlugin.lint');
+        }
+    }
+    constructor(...args){
+        super(...args), this.name = 'rules', this.done = async (stats)=>{
+            (0, logger_namespaceObject.time)('InternalRulesPlugin.done');
+            try {
+                await this.lint(stats.compilation);
+            } finally{
+                (0, logger_namespaceObject.timeEnd)('InternalRulesPlugin.done');
+            }
+        };
+    }
+}
+exports.InternalRulesPlugin = __webpack_exports__.InternalRulesPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "InternalRulesPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});