@rsdoctor/core 0.0.0-next-20240620044732

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

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bundle_exports = {};
+__export(bundle_exports, {
+  InternalBundlePlugin: () => InternalBundlePlugin
+});
+module.exports = __toCommonJS(bundle_exports);
+var import_types = require("@rsdoctor/types");
+var import_base = require("./base");
+var import_common = require("../../build-utils/common");
+class InternalBundlePlugin extends import_base.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "bundle";
+    this.map = /* @__PURE__ */ new Map();
+    this.thisCompilation = (compilation) => {
+      if (compilation.hooks.processAssets && "afterOptimizeAssets" in compilation.hooks) {
+        compilation.hooks.afterOptimizeAssets.tap(
+          this.tapPostOptions,
+          (assets) => {
+            Object.keys(assets).forEach((file) => {
+              const v = this.ensureAssetContent(file);
+              v.content = assets[file].source().toString();
+            });
+          }
+        );
+      } else if (compilation.hooks.processAssets && "afterProcessAssets" in compilation.hooks) {
+        compilation.hooks.afterProcessAssets.tap(
+          this.tapPostOptions,
+          () => {
+            Object.keys(compilation.assets).forEach((file) => {
+              const v = this.ensureAssetContent(file);
+              v.content = compilation.assets[file].source().toString();
+            });
+          }
+        );
+      } else if ("afterOptimizeChunkAssets" in compilation.hooks) {
+        compilation.hooks.afterOptimizeChunkAssets.tap(
+          this.tapPostOptions,
+          (chunks) => {
+            [...chunks].reduce((t, chunk) => t.concat([...chunk.files]), []).forEach((file) => {
+              const v = this.ensureAssetContent(file);
+              v.content = compilation.assets[file].source().toString();
+            });
+          }
+        );
+      }
+    };
+    this.done = async () => {
+      if (this.scheduler.chunkGraph) {
+        import_common.Chunks.assetsContents(this.map, this.scheduler.chunkGraph);
+      }
+      this.sdk.addClientRoutes([
+        import_types.Manifest.RsdoctorManifestClientRoutes.ModuleGraph,
+        import_types.Manifest.RsdoctorManifestClientRoutes.BundleSize
+      ]);
+    };
+  }
+  apply(compiler) {
+    this.scheduler.ensureModulesChunksGraphApplied(compiler);
+    compiler.hooks.compilation.tap(this.tapPostOptions, this.thisCompilation);
+    compiler.hooks.done.tapPromise(this.tapPreOptions, this.done.bind(this));
+  }
+  ensureAssetContent(name) {
+    const asset = this.map.get(name);
+    if (asset)
+      return asset;
+    const v = { content: "" };
+    this.map.set(name, v);
+    return v;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalBundlePlugin
+});

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

@@ -0,0 +1,7 @@
+import { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalBundleTagPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "bundleTag";
+    apply(compiler: Plugin.BaseCompiler): void;
+}
+//# sourceMappingURL=bundleTagPlugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bundleTagPlugin.d.ts","sourceRoot":"","sources":["../../../src/inner-plugins/plugins/bundleTagPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAG5C,qBAAa,uBAAuB,CAClC,CAAC,SAAS,MAAM,CAAC,YAAY,CAC7B,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC7B,SAAgB,IAAI,eAAe;IAE5B,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,YAAY;CAmD3C"}

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

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bundleTagPlugin_exports = {};
+__export(bundleTagPlugin_exports, {
+  InternalBundleTagPlugin: () => InternalBundleTagPlugin
+});
+module.exports = __toCommonJS(bundleTagPlugin_exports);
+var import_path = require("path");
+var import_webpack_sources = require("webpack-sources");
+var import_base = require("./base");
+var import_logger = require("@rsdoctor/utils/logger");
+class InternalBundleTagPlugin extends import_base.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "bundleTag";
+  }
+  apply(compiler) {
+    const supportBannerPlugin = !!this.options.supports?.banner;
+    compiler.hooks.compilation.tap("RsdoctorTagBannerPlugin", (compilation) => {
+      compilation.hooks.processAssets.tapPromise(
+        {
+          name: "RsdoctorTagBannerPlugin",
+          stage: -2e3
+        },
+        async () => {
+          if (!compilation.options.plugins.map((p) => p && p.constructor.name).includes("BannerPlugin") && !supportBannerPlugin) {
+            return;
+          }
+          import_logger.logger.info(
+            import_logger.chalk.bgMagenta(
+              "Rsdoctor BannerTagPlugin has open. Do not use Rsdoctor on production version."
+            )
+          );
+          const chunks = compilation.chunks;
+          for (let chunk of chunks) {
+            for (const file of chunk.files) {
+              if (!file || (0, import_path.extname)(file) !== ".js") {
+                continue;
+              }
+              compilation.updateAsset(
+                file,
+                // @ts-ignore
+                (old) => {
+                  const concatSource = new import_webpack_sources.ConcatSource();
+                  let header = "\n console.log('RSDOCTOR_START::');\n";
+                  let footer = "\n console.log('RSDOCTOR_END::');\n";
+                  concatSource.add(header);
+                  concatSource.add(old);
+                  concatSource.add(footer);
+                  return concatSource;
+                },
+                () => {
+                }
+              );
+            }
+          }
+        }
+      );
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalBundleTagPlugin
+});

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

@@ -0,0 +1,10 @@
+import { RsdoctorPluginInstance } from '../../types';
+import { Linter, Plugin } from '@rsdoctor/types';
+/**
+ * @description Generate ModuleGraph and ChunkGraph from stats and webpack module apis;
+ * @param {Compiler} compiler
+ * @return {*}
+ * @memberof RsdoctorWebpackPlugin
+ */
+export declare const ensureModulesChunksGraphFn: (compiler: Plugin.BaseCompiler, _this: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>) => void;
+//# sourceMappingURL=ensureModulesChunkGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ensureModulesChunkGraph.d.ts","sourceRoot":"","sources":["../../../src/inner-plugins/plugins/ensureModulesChunkGraph.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEjD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAuB,MAAM,iBAAiB,CAAC;AAWtE;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,aAC3B,OAAO,YAAY,SACtB,uBAAuB,OAAO,YAAY,EAAE,OAAO,cAAc,EAAE,CAAC,SAsF5E,CAAC"}

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

@@ -0,0 +1,126 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ensureModulesChunkGraph_exports = {};
+__export(ensureModulesChunkGraph_exports, {
+  ensureModulesChunksGraphFn: () => ensureModulesChunksGraphFn
+});
+module.exports = __toCommonJS(ensureModulesChunkGraph_exports);
+var import_path = __toESM(require("path"));
+var import_types2 = require("@rsdoctor/types");
+var import_build = require("@rsdoctor/utils/build");
+var import_logger = require("@rsdoctor/utils/logger");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_build2 = require("../../build-utils/build");
+var import_common = require("../../build-utils/common");
+var import_constants = require("../constants");
+const ensureModulesChunksGraphFn = (compiler, _this) => {
+  if (_this._modulesGraphApplied)
+    return;
+  _this._modulesGraphApplied = true;
+  const context = {
+    astCache: /* @__PURE__ */ new Map(),
+    packagePathMap: /* @__PURE__ */ new Map(),
+    getSourceMap: (file) => {
+      return _this.sdk.getSourceMap(file);
+    }
+  };
+  compiler.hooks.done.tapPromise(
+    (0, import_constants.internalPluginTapPreOptions)("moduleGraph"),
+    async (_stats) => {
+      const stats = _stats;
+      const statsJson = stats.toJson();
+      (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[Before Generate ModuleGraph]");
+      _this.chunkGraph = import_build2.Chunks.chunkTransform(/* @__PURE__ */ new Map(), statsJson);
+      _this.modulesGraph = await import_build2.ModuleGraph.getModuleGraphByStats(
+        stats.compilation,
+        statsJson,
+        process.cwd(),
+        _this.chunkGraph,
+        _this.options.features,
+        context
+      );
+      (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After Generate ModuleGraph]");
+      if (_this.options.features.treeShaking) {
+        _this.modulesGraph = import_build2.ModuleGraph.appendTreeShaking(
+          _this.modulesGraph,
+          stats.compilation
+        ) || _this.modulesGraph;
+        _this.sdk.addClientRoutes([
+          import_types2.Manifest.RsdoctorManifestClientRoutes.TreeShaking
+        ]);
+        (0, import_logger.debug)(
+          import_build.Process.getMemoryUsageMessage,
+          "[After AppendTreeShaking to ModuleGraph]"
+        );
+      }
+      const shouldParseBundle = _this.options.supports.parseBundle !== false;
+      await getModulesInfosByStats(
+        compiler,
+        statsJson,
+        _this.modulesGraph,
+        shouldParseBundle
+      );
+      (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After Transform ModuleGraph]");
+      _this.modulesGraph && await _this.sdk.reportModuleGraph(_this.modulesGraph);
+      await _this.sdk.reportChunkGraph(_this.chunkGraph);
+      const reportFilePath = await import_build2.Chunks.generateTileGraph(
+        statsJson,
+        {
+          reportFilename: import_path.default.join(
+            import_types2.Constants.RsdoctorOutputFolder,
+            import_build2.Chunks.TileGraphReportName
+          ),
+          reportTitle: "bundle-analyzer"
+        },
+        compiler.outputPath
+      );
+      reportFilePath && await _this.sdk.reportTileHtml(
+        import_fs_extra.default.readFileSync(reportFilePath, "utf-8")
+      );
+    }
+  );
+};
+async function getModulesInfosByStats(compiler, stats, moduleGraph, parseBundle) {
+  if (!moduleGraph) {
+    return;
+  }
+  try {
+    const parsedModulesData = await import_build2.Chunks.getAssetsModulesData(
+      stats,
+      compiler.outputPath,
+      parseBundle
+    ) || {};
+    import_common.Chunks.transformAssetsModulesData(parsedModulesData, moduleGraph);
+  } catch (e) {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureModulesChunksGraphFn
+});

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

@@ -0,0 +1,12 @@
+import { Rule, Err, Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+import { DevToolError } from '@rsdoctor/utils/error';
+export declare class InternalErrorReporterPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "error-reporter";
+    apply(compiler: T): void;
+    done: (stats: Plugin.BaseStats) => Promise<void>;
+    handleWebpackError(err: Plugin.BuildError, category: Rule.RuleMessageCategory, level: keyof typeof Err.ErrorLevel): DevToolError;
+    reportWarnings(warnings: Plugin.BuildError[]): Promise<void>;
+    reportErrors(errors: Plugin.BuildWarning[]): Promise<void>;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/inner-plugins/plugins/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,qBAAa,2BAA2B,CACtC,CAAC,SAAS,MAAM,CAAC,YAAY,CAC7B,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC7B,SAAgB,IAAI,oBAAoB;IAEjC,KAAK,CAAC,QAAQ,EAAE,CAAC;IAIjB,IAAI,UAAiB,OAAO,SAAS,KAAG,QAAQ,IAAI,CAAC,CAiB1D;IAEK,kBAAkB,CACvB,GAAG,EAAE,MAAM,CAAC,UAAU,EACtB,QAAQ,EAAE,IAAI,CAAC,mBAAmB,EAClC,KAAK,EAAE,MAAM,OAAO,GAAG,CAAC,UAAU;IAavB,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,UAAU,EAAE;IAW5C,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,EAAE;CAUxD"}

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

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  InternalErrorReporterPlugin: () => InternalErrorReporterPlugin
+});
+module.exports = __toCommonJS(errors_exports);
+var import_types = require("@rsdoctor/types");
+var import_base = require("./base");
+var import_error = require("@rsdoctor/utils/error");
+class InternalErrorReporterPlugin extends import_base.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "error-reporter";
+    this.done = async (stats) => {
+      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);
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
+  }
+  handleWebpackError(err, category, level) {
+    return import_error.DevToolError.from(err, {
+      category,
+      code: import_types.Rule.RuleMessageCodeEnumerated.Overlay,
+      controller: { noStack: false },
+      detail: {
+        stack: "stack" in err ? err.stack : err.message
+      },
+      level
+    });
+  }
+  async reportWarnings(warnings) {
+    const arr = warnings.map((warning) => {
+      return this.handleWebpackError(
+        warning,
+        import_types.Rule.RuleMessageCategory.Compile,
+        "Warn"
+      );
+    });
+    this.sdk.reportError(arr);
+  }
+  async reportErrors(errors) {
+    const arr = errors.map((err) => {
+      return this.handleWebpackError(
+        err,
+        import_types.Rule.RuleMessageCategory.Bundle,
+        "Error"
+      );
+    });
+    this.sdk.reportError(arr);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalErrorReporterPlugin
+});

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

@@ -0,0 +1,11 @@
+export * from './loader';
+export * from './plugins';
+export * from './errors';
+export * from './progress';
+export * from './summary';
+export * from './base';
+export * from './bundle';
+export * from './ensureModulesChunkGraph';
+export * from './rules';
+export * from './bundleTagPlugin';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/inner-plugins/plugins/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC"}

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

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugins_exports = {};
+module.exports = __toCommonJS(plugins_exports);
+__reExport(plugins_exports, require("./loader"), module.exports);
+__reExport(plugins_exports, require("./plugins"), module.exports);
+__reExport(plugins_exports, require("./errors"), module.exports);
+__reExport(plugins_exports, require("./progress"), module.exports);
+__reExport(plugins_exports, require("./summary"), module.exports);
+__reExport(plugins_exports, require("./base"), module.exports);
+__reExport(plugins_exports, require("./bundle"), module.exports);
+__reExport(plugins_exports, require("./ensureModulesChunkGraph"), module.exports);
+__reExport(plugins_exports, require("./rules"), module.exports);
+__reExport(plugins_exports, require("./bundleTagPlugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./loader"),
+  ...require("./plugins"),
+  ...require("./errors"),
+  ...require("./progress"),
+  ...require("./summary"),
+  ...require("./base"),
+  ...require("./bundle"),
+  ...require("./ensureModulesChunkGraph"),
+  ...require("./rules"),
+  ...require("./bundleTagPlugin")
+});

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

@@ -0,0 +1,12 @@
+import { Plugin } from '@rsdoctor/types';
+import { RuleSetRule } from 'webpack';
+import { InternalBasePlugin } from './base';
+export declare class InternalLoaderPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "loader";
+    readonly internalLoaderPath: string;
+    apply(compiler: T): void;
+    afterPlugins: (compiler: Plugin.BaseCompiler) => void;
+    compilation(compiler: Plugin.BaseCompiler, compilation: Plugin.BaseCompilation): void;
+    getInterceptRules(compiler: Plugin.BaseCompiler, rules: RuleSetRule[]): RuleSetRule[];
+}
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/inner-plugins/plugins/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,EAA+B,WAAW,EAAE,MAAM,SAAS,CAAC;AAEnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAG5C,qBAAa,oBAAoB,CAC/B,CAAC,SAAS,MAAM,CAAC,YAAY,CAC7B,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC7B,SAAgB,IAAI,YAAY;IAEhC,SAAgB,kBAAkB,SAAuC;IAElE,KAAK,CAAC,QAAQ,EAAE,CAAC;IAUjB,YAAY,aAAc,OAAO,YAAY,UAYlD;IAEK,WAAW,CAChB,QAAQ,EAAE,MAAM,CAAC,YAAY,EAC7B,WAAW,EAAE,MAAM,CAAC,eAAe;IA4G9B,iBAAiB,CACtB,QAAQ,EAAE,MAAM,CAAC,YAAY,EAC7B,KAAK,EAAE,WAAW,EAAE;CAcvB"}

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

@@ -0,0 +1,161 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+__export(loader_exports, {
+  InternalLoaderPlugin: () => InternalLoaderPlugin
+});
+module.exports = __toCommonJS(loader_exports);
+var import_types = require("@rsdoctor/types");
+var import_common = require("@rsdoctor/utils/common");
+var import_lodash = require("lodash");
+var import_utils = require("../utils");
+var import_base = require("./base");
+class InternalLoaderPlugin extends import_base.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "loader";
+    this.internalLoaderPath = require.resolve("../loaders/proxy");
+    this.afterPlugins = (compiler) => {
+      if (compiler.isChild())
+        return;
+      compiler.options.module.rules = this.getInterceptRules(
+        compiler,
+        compiler.options.module.rules
+      );
+      this.sdk.addClientRoutes([
+        import_types.Manifest.RsdoctorManifestClientRoutes.WebpackLoaders
+      ]);
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins);
+    compiler.hooks.compilation.tap(
+      this.tapPreOptions,
+      this.compilation.bind(this, compiler)
+    );
+  }
+  compilation(compiler, compilation) {
+    if (compiler.isChild())
+      return;
+    const wrapper = (callback) => (loaderContext, module2) => {
+      const proxyLoaders = module2.loaders || loaderContext?.loaders || [];
+      const originLoaders = proxyLoaders.map((loader) => {
+        const opts = loader.options || {};
+        if (opts[import_common.Loader.LoaderInternalPropertyName]) {
+          return {
+            ...loader,
+            loader: opts[import_common.Loader.LoaderInternalPropertyName].loader,
+            options: (0, import_lodash.omit)(opts, import_common.Loader.LoaderInternalPropertyName)
+          };
+        }
+        return loader;
+      });
+      const newLoaders = (0, import_lodash.cloneDeep)(originLoaders);
+      if (typeof compiler.options.cache === "object" && "version" in compiler.options.cache && typeof compiler.options.cache.version === "string" && compiler.options.cache.version.indexOf("next/dist/build") > -1) {
+        callback(loaderContext, module2);
+      } else {
+        const proxyModule = new Proxy(module2, {
+          get(target, p, receiver) {
+            if (p === "loaders")
+              return newLoaders;
+            return Reflect.get(target, p, receiver);
+          },
+          set(target, p, newValue, receiver) {
+            const _newValue = (0, import_lodash.cloneDeep)(newValue);
+            if (p === "loaders") {
+              if (Array.isArray(_newValue)) {
+                newLoaders.length = 0;
+                _newValue.forEach((e) => {
+                  newLoaders.push(e);
+                });
+              }
+            }
+            return Reflect.set(target, p, _newValue, receiver);
+          },
+          deleteProperty(target, p) {
+            return Reflect.deleteProperty(target, p);
+          }
+        });
+        callback(loaderContext, proxyModule);
+      }
+      if (!(0, import_lodash.isEqual)(originLoaders, newLoaders)) {
+        const rules = this.getInterceptRules(
+          compiler,
+          newLoaders.map((e) => {
+            return {
+              loader: e.loader,
+              options: e.options
+            };
+          })
+        );
+        module2.loaders = rules.map((e, i) => {
+          return {
+            ...newLoaders[i],
+            loader: e.loader,
+            options: e.options
+          };
+        });
+      }
+    };
+    const interceptor = {
+      register(tap) {
+        const originFn = tap.fn;
+        if (typeof originFn === "function") {
+          tap.fn = wrapper(originFn);
+        }
+        return tap;
+      }
+    };
+    if (compiler.webpack?.NormalModule?.getCompilationHooks) {
+      compiler.webpack.NormalModule.getCompilationHooks(
+        compilation
+      ).loader.intercept(interceptor);
+    } else if ("normalModuleLoader" in compilation.hooks) {
+      "normalModuleLoader" in compilation.hooks && compilation.hooks.normalModuleLoader.intercept(interceptor);
+    }
+  }
+  getInterceptRules(compiler, rules) {
+    return (0, import_utils.interceptLoader)(
+      rules,
+      this.internalLoaderPath,
+      {
+        cwd: compiler.context || process.cwd(),
+        host: this.sdk.server.origin,
+        skipLoaders: this.options.loaderInterceptorOptions.skipLoaders
+        // not implement
+      },
+      this.sdk.root,
+      "resolveLoader" in compiler.options ? compiler.options.resolveLoader : {}
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalLoaderPlugin
+});