@rsdoctor/core 0.0.2-beta.0

package/dist/rules/rules/ecma-version-check/index.js

@@ -0,0 +1,82 @@
+"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 ecma_version_check_exports = {};
+__export(ecma_version_check_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(ecma_version_check_exports);
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+var import_path = __toESM(require("path"));
+var import_rule = require("../../rule");
+var import_utils = require("./utils");
+var import_types2 = require("@rsdoctor/types");
+const title = "ecma-version-check";
+const rule = (0, import_rule.defineRule)(() => {
+  return {
+    meta: {
+      code: "E1004",
+      title,
+      category: "bundle",
+      severity: import_types2.Linter.Severity.Warn,
+      defaultConfig: {
+        highestVersion: import_ruleUtils.ECMAVersion.ES5,
+        ignore: []
+      }
+    },
+    check({ chunkGraph, report, ruleConfig }) {
+      for (const asset of chunkGraph.getAssets()) {
+        if (import_path.default.extname(asset.path) !== ".js") {
+          continue;
+        }
+        if (ruleConfig.ignore.includes(asset.path)) {
+          continue;
+        }
+        const currentVersion = import_ruleUtils.parser.utils.detectECMAVersion(asset.content);
+        const currentVersionNumber = (0, import_utils.getVersionNumber)(currentVersion);
+        const configVersionNumber = (0, import_utils.getVersionNumber)(ruleConfig.highestVersion);
+        if (!configVersionNumber || !currentVersionNumber) {
+          return;
+        }
+        if (currentVersionNumber > configVersionNumber) {
+          const assetsName = import_path.default.basename(asset.path);
+          report({
+            message: `The ECMA version of asset ${assetsName} is ${currentVersion}, which is bigger than ${ruleConfig.highestVersion}.`,
+            detail: {
+              type: "link"
+            }
+          });
+        }
+      }
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/dist/rules/rules/ecma-version-check/types.d.ts

@@ -0,0 +1,7 @@
+import type { ECMAVersion } from '@rsdoctor/utils/ruleUtils';
+export interface Config {
+  /** Check the ecma version */
+  highestVersion: ECMAVersion;
+  /** Js files that need to be ignored */
+  ignore: string[];
+}

package/dist/rules/rules/ecma-version-check/types.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/rules/rules/ecma-version-check/utils.d.ts

@@ -0,0 +1,2 @@
+import type { ECMAVersion } from '@rsdoctor/utils/ruleUtils';
+export declare function getVersionNumber(ECMAString: ECMAVersion): number | undefined;

package/dist/rules/rules/ecma-version-check/utils.js

@@ -0,0 +1,31 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  getVersionNumber: () => getVersionNumber
+});
+module.exports = __toCommonJS(utils_exports);
+function getVersionNumber(ECMAString) {
+  const version = ECMAString.match(/\d/);
+  return version?.length ? Number(version[0]) : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getVersionNumber
+});

package/dist/rules/rules/index.d.ts

@@ -0,0 +1 @@
+export declare const rules: (import("@rsdoctor/types/dist/linter").RuleData<import("./duplicate-package").Config, "duplicate-package"> | import("@rsdoctor/types/dist/linter").RuleData<import("./default-import-check").Config, "default-import-check"> | import("@rsdoctor/types/dist/linter").RuleData<import("./loader-performance-optimization").Config, "loader-performance-optimization"> | import("@rsdoctor/types/dist/linter").RuleData<import("./ecma-version-check").Config, "ecma-version-check">)[];

package/dist/rules/rules/index.js

@@ -0,0 +1,37 @@
+"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 rules_exports = {};
+__export(rules_exports, {
+  rules: () => rules
+});
+module.exports = __toCommonJS(rules_exports);
+var import_duplicate_package = require("./duplicate-package");
+var import_default_import_check = require("./default-import-check");
+var import_loader_performance_optimization = require("./loader-performance-optimization");
+var import_ecma_version_check = require("./ecma-version-check");
+const rules = [
+  import_duplicate_package.rule,
+  import_default_import_check.rule,
+  import_loader_performance_optimization.rule,
+  import_ecma_version_check.rule
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rules
+});

package/dist/rules/rules/loader-performance-optimization/index.d.ts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "loader-performance-optimization">;

package/dist/rules/rules/loader-performance-optimization/index.js

@@ -0,0 +1,121 @@
+"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 loader_performance_optimization_exports = {};
+__export(loader_performance_optimization_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(loader_performance_optimization_exports);
+var import_types = require("@rsdoctor/types");
+var import_common = require("@rsdoctor/utils/common");
+var import_rule = require("../../rule");
+var import_utils = require("./utils");
+const title = "loader-performance-optimization";
+const rule = (0, import_rule.defineRule)(() => {
+  return {
+    meta: {
+      code: "E1003",
+      title,
+      category: "compile",
+      severity: import_types.Linter.Severity.Warn,
+      defaultConfig: {
+        ignore: [],
+        threshold: 5e3,
+        extensions: ["js", "css", "jpg", "jpeg", "png", "gif", "webp", "svg"]
+      }
+    },
+    check({ loader, configs, root, ruleConfig, report }) {
+      const { extensions, ignore, threshold } = ruleConfig;
+      if (extensions.length === 0)
+        return;
+      if (loader.length === 0)
+        return;
+      const { config } = configs.find((e) => e.name === "webpack");
+      const cwd = config.context || root;
+      const nodeModulesPathRegexp = /\/node_modules\//;
+      const resultMap = /* @__PURE__ */ new Map();
+      const loaders = loader.map((el) => el.loaders).reduce((t, c) => t.concat(c));
+      for (const item of loader) {
+        const { path, ext } = item.resource;
+        if (!(0, import_utils.match)(ext, extensions))
+          continue;
+        if (nodeModulesPathRegexp.test(path) || !path.startsWith(cwd)) {
+          item.loaders.forEach((el) => {
+            if ((0, import_utils.match)(el.loader, ignore))
+              return;
+            const costs = import_common.Loader.getLoaderCosts(el, loaders);
+            const v = {
+              ...el,
+              __resource__: item.resource,
+              __costs__: costs
+            };
+            if (resultMap.has(el.loader)) {
+              resultMap.get(el.loader).push(v);
+            } else {
+              resultMap.set(el.loader, [v]);
+            }
+          });
+        }
+      }
+      const sum = (arr) => {
+        const v1 = arr.reduce((t, c) => t + c.__costs__, 0);
+        const v2 = Math.max.apply(
+          null,
+          arr.map((e) => e.endAt)
+        ) - Math.min.apply(arr.map((e) => e.startAt));
+        if (v2 >= v1)
+          return v1;
+        return v2;
+      };
+      for (const [loaderName, v] of resultMap.entries()) {
+        const nodeModulesFiles = v.filter(
+          (e) => nodeModulesPathRegexp.test(e.__resource__.path)
+        );
+        const nodeModulesFilesCosts = sum(nodeModulesFiles);
+        const outofCwdFiles = v.filter(
+          (e) => !e.__resource__.path.startsWith(cwd)
+        );
+        const outofCwdFilesCosts = sum(outofCwdFiles);
+        const msg = [
+          nodeModulesFilesCosts >= threshold && `<b>${nodeModulesFiles.length}</b> node_modules files(costs: <b>${import_common.Time.formatCosts(
+            nodeModulesFilesCosts
+          )}</b>)`,
+          outofCwdFilesCosts >= threshold && `<b>${outofCwdFiles.length}</b> outof project files(costs: <b>${import_common.Time.formatCosts(
+            outofCwdFilesCosts
+          )}</b>)`
+        ].filter(Boolean).join(" and ");
+        if (msg) {
+          const message = `<b>${loaderName}</b> has process ${msg}.`;
+          report({
+            message,
+            detail: {
+              description: message,
+              type: "link"
+              // nodeModulesFiles,
+              // outofCwdFiles,
+            }
+          });
+        }
+      }
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/dist/rules/rules/loader-performance-optimization/types.d.ts

@@ -0,0 +1,22 @@
+import type { SDK } from '@rsdoctor/types';
+export interface Config {
+  /**
+   * loaders which should be ignore.
+   */
+  ignore: (string | RegExp)[];
+  /**
+   * threshold which the loader total costs.
+   * @unit millisecond
+   * @default 5000
+   */
+  threshold: number;
+  /**
+   * the file extensions which will be match in rule check.
+   * @default ["js", "css", "jpg", "jpeg", "png", "gif", "webp", "svg"]
+   */
+  extensions: (string | RegExp)[];
+}
+export interface LoaderMapValue extends SDK.LoaderTransformData {
+  __resource__: SDK.ResourceData;
+  __costs__: number;
+}

package/dist/rules/rules/loader-performance-optimization/types.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/rules/rules/loader-performance-optimization/utils.d.ts

@@ -0,0 +1 @@
+export declare function match(str: string, partterns: (string | RegExp)[]): boolean;

package/dist/rules/rules/loader-performance-optimization/utils.js

@@ -0,0 +1,38 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  match: () => match
+});
+module.exports = __toCommonJS(utils_exports);
+function match(str, partterns) {
+  if (partterns.length === 0)
+    return false;
+  return partterns.some((p) => {
+    if (typeof p === "string")
+      return str === p;
+    if (p instanceof RegExp)
+      return p.test(str);
+    return false;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  match
+});

package/dist/rules/utils.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from '@rsdoctor/types';
+export declare function toSeverity(input: Linter.SeverityInput, defaultLevel: Linter.Severity): Linter.Severity;
+export declare function noop(): void;

package/dist/rules/utils.js

@@ -0,0 +1,44 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  noop: () => noop,
+  toSeverity: () => toSeverity
+});
+module.exports = __toCommonJS(utils_exports);
+var import_types = require("@rsdoctor/types");
+function toSeverity(input, defaultLevel) {
+  if (input === "off") {
+    return import_types.Linter.Severity.Ignore;
+  }
+  if (input === "on") {
+    return defaultLevel;
+  }
+  const key = `${input[0].toUpperCase()}${input.slice(
+    1
+  )}`;
+  return import_types.Linter.Severity[key];
+}
+function noop() {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  noop,
+  toSeverity
+});

package/dist/types/chunks.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from '@rsdoctor/types';
+export type AssetsModules = {
+  label?: string;
+  isAsset?: boolean;
+  modules?: Plugin.StatsModule[];
+};
+export type ParseBundle = (assetFile: string, modules: Plugin.StatsModule[]) => {
+  modules?: Record<string, any>;
+  src?: string;
+  runtimeSrc?: string;
+};

package/dist/types/chunks.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunks_exports = {};
+module.exports = __toCommonJS(chunks_exports);

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './chunks';
+export * from './rules';
+export * from './webpack';
+export * from './loader';
+export * from './plugin';

package/dist/types/index.js

@@ -0,0 +1,30 @@
+"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 types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./chunks"), module.exports);
+__reExport(types_exports, require("./rules"), module.exports);
+__reExport(types_exports, require("./webpack"), module.exports);
+__reExport(types_exports, require("./loader"), module.exports);
+__reExport(types_exports, require("./plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./chunks"),
+  ...require("./rules"),
+  ...require("./webpack"),
+  ...require("./loader"),
+  ...require("./plugin")
+});

package/dist/types/loader.d.ts

@@ -0,0 +1,19 @@
+import { Loader } from '@rsdoctor/utils/common';
+export interface ProxyLoaderInternalOptions {
+  cwd: string;
+  /**
+   * the url host of http server(which used to collect data).
+   */
+  host: string;
+  /**
+   * correct loader path.
+   */
+  loader: string;
+  /** include the loader option */
+  hasOptions: boolean;
+  skipLoaders: string[];
+}
+export interface ProxyLoaderOptions {
+  [key: string]: any;
+  [Loader.LoaderInternalPropertyName]: ProxyLoaderInternalOptions;
+}

package/dist/types/loader.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+module.exports = __toCommonJS(loader_exports);

package/dist/types/plugin.d.ts

@@ -0,0 +1,72 @@
+import type { Linter as LinterType, Common, Plugin, SDK } from '@rsdoctor/types';
+import type { DoctorSlaveSDK, DoctorWebpackSDK } from '@rsdoctor/sdk';
+import { ModuleGraph } from '@rsdoctor/graph';
+type InternalRules = any;
+export interface DoctorWebpackPluginOptions<Rules extends LinterType.ExtendRuleData[]> {
+  /** Checker configuration */
+  linter?: LinterType.Options<Rules, InternalRules>;
+  /**
+   * the switch for the Rsdoctor features.
+   */
+  features?: Plugin.DoctorWebpackPluginFeatures | Array<keyof Plugin.DoctorWebpackPluginFeatures>;
+  /**
+   * configuration of the interceptor for webpack loaders.
+   * @description worked when the `features.loader === true`.
+   */
+  loaderInterceptorOptions?: {
+    /**
+     * loaders which you want to skip it (will not report the target loader data when webpack compile).
+     */
+    skipLoaders?: string[];
+  };
+  /**
+   * turn on it if you don't need to see profile in browser.
+   * @default false
+   */
+  disableClientServer?: boolean;
+  /**
+   * sdk instance of outside
+   */
+  sdkInstance?: DoctorWebpackSDK;
+  /**
+   * control the Rsdoctor reporter codes records.
+   */
+  reportCodeType?: {
+    noModuleSource?: boolean;
+    noAssetsAndModuleSource?: boolean;
+  } | undefined;
+  /**
+   * control the Rsdoctor upload data to TOS.
+   * @default false
+   */
+  disableTOSUpload?: boolean;
+}
+export interface DoctorWebpackMultiplePluginOptions<Rules extends LinterType.ExtendRuleData[] = LinterType.ExtendRuleData[]> extends Omit<DoctorWebpackPluginOptions<Rules>, 'sdkInstance'>, Pick<ConstructorParameters<typeof DoctorSlaveSDK>[0], 'stage'> {
+  /**
+   * name of builder
+   */
+  name?: string;
+}
+export interface DoctorPluginOptionsNormalized<Rules extends LinterType.ExtendRuleData[] = []> extends Common.DeepRequired<Omit<DoctorWebpackPluginOptions<Rules>, 'sdkInstance' | 'linter' | 'reportCodeType'>> {
+  features: Common.DeepRequired<Plugin.DoctorWebpackPluginFeatures>;
+  linter: Required<LinterType.Options<Rules, InternalRules>>;
+  sdkInstance?: DoctorWebpackSDK;
+  reportCodeType?: SDK.ToDataType;
+}
+export interface BasePluginInstance<T extends Plugin.BaseCompiler> {
+  apply: (compiler: T) => void;
+  [k: string]: any;
+}
+export interface InternalPlugin<T extends Plugin.BaseCompiler, Rules extends LinterType.ExtendRuleData[] = []> extends BasePluginInstance<T> {
+  readonly name: string;
+  readonly scheduler: DoctorPluginInstance<T, Rules>;
+}
+export interface DoctorPluginInstance<T extends Plugin.BaseCompiler, Rules extends LinterType.ExtendRuleData[] = []> extends BasePluginInstance<T> {
+  readonly name: string;
+  readonly options: DoctorPluginOptionsNormalized<Rules>;
+  readonly sdk: DoctorWebpackSDK;
+  modulesGraph: ModuleGraph;
+  ensureModulesChunksGraphApplied(compiler: T): void;
+}
+export interface DoctorRspackPluginOptions<Rules extends LinterType.ExtendRuleData[]> extends DoctorWebpackPluginOptions<Rules> {}
+export {};

package/dist/types/plugin.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+module.exports = __toCommonJS(plugin_exports);

package/dist/types/rules.d.ts

@@ -0,0 +1,7 @@
+import { RuleSetRule } from 'webpack';
+export interface Rule extends RuleSetRule {
+  /**
+   * https://webpack.js.org/configuration/module/#ruleloaders
+   */
+  loaders: RuleSetRule['use'];
+}