@rsdoctor/core 0.0.2-beta.0

package/dist/build-utils/common/webpack/compatible.js

@@ -0,0 +1,181 @@
+"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 compatible_exports = {};
+__export(compatible_exports, {
+  getAllModules: () => getAllModules,
+  getDependencyPosition: () => getDependencyPosition,
+  getEntryModule: () => getEntryModule,
+  getExportDependency: () => getExportDependency,
+  getExportStatement: () => getExportStatement,
+  getLastExportInfo: () => getLastExportInfo,
+  getModuleExportsType: () => getModuleExportsType,
+  getModuleSource: () => getModuleSource,
+  getResolveModule: () => getResolveModule,
+  getResolveRequest: () => getResolveRequest,
+  getSdkDependencyByWebpackDependency: () => getSdkDependencyByWebpackDependency,
+  getWebpackDependencyRequest: () => getWebpackDependencyRequest,
+  getWebpackModuleId: () => getWebpackModuleId,
+  getWebpackModulePath: () => getWebpackModulePath,
+  isExternalModule: () => isExternalModule,
+  isNormalModule: () => isNormalModule
+});
+module.exports = __toCommonJS(compatible_exports);
+var import_lodash = require("lodash");
+var import_graph = require("@rsdoctor/graph");
+function isNormalModule(mod) {
+  return "request" in mod && "rawRequest" in mod && "resource" in mod;
+}
+function getWebpackModuleId(mod) {
+  return mod.identifier();
+}
+function getWebpackModulePath(mod) {
+  return mod.resource ?? mod.nameForCondition?.() ?? getWebpackModuleId(mod);
+}
+function getWebpackDependencyRequest(dep, module2) {
+  return dep.request ?? dep.userRequest ?? module2?.rawRequest;
+}
+function getResolveRequest(dep, graph) {
+  return getWebpackModulePath(graph.getResolvedModule(dep));
+}
+function isExternalModule(mod) {
+  return Boolean(mod.externalType);
+}
+function getModuleSource(mod) {
+  return isExternalModule(mod) ? "" : mod.originalSource?.()?.source().toString() ?? "";
+}
+function getResolveModule(dep, graph) {
+  if (graph) {
+    return graph.getResolvedModule(dep);
+  }
+  return dep.module ?? void 0;
+}
+function getEntryModule(entryMap) {
+  return Array.from(entryMap.values()).map((entry) => entry.getRuntimeChunk()).map((chunk) => chunk ? chunk.entryModule : null).filter(Boolean).map((mod) => isNormalModule(mod) ? mod : mod.rootModule);
+}
+function getModuleExportsType(module2, moduleGraph, strict = false) {
+  if (moduleGraph) {
+    return module2.getExportsType(moduleGraph, strict);
+  }
+  const exportsType = module2.buildMeta && module2.buildMeta.exportsType;
+  if (!exportsType && !strict) {
+    return "dynamic";
+  }
+  if (exportsType === "named") {
+    return "namespace";
+  }
+  return strict ? "default-with-named" : "dynamic";
+}
+function getDependencyPosition(dep, module2, getSource = true) {
+  const { loc: depLoc } = dep;
+  if (!("start" in depLoc)) {
+    return;
+  }
+  const transformed = {
+    start: {
+      line: depLoc.start.line,
+      column: depLoc.start.column
+    },
+    end: depLoc.end ? {
+      line: depLoc.end.line,
+      column: depLoc.end.column
+    } : void 0
+  };
+  const statement = new import_graph.Statement(module2, {
+    source: getSource ? module2.getSourceRange(transformed) : void 0,
+    transformed
+  });
+  return statement;
+}
+function getExportDependency(info, module2) {
+  let dep = module2.dependencies.find((dep2) => {
+    return dep2.name === info.name && (dep2.type === "harmony export imported specifier" || dep2.type === "harmony export specifier");
+  });
+  if (!dep && info._target && info._target.size > 0) {
+    dep = info._getMaxTarget().values().next().value.connection.dependency;
+  }
+  return dep;
+}
+function getSdkDependencyByWebpackDependency(dep, module2, graph) {
+  const modulePath = getWebpackModulePath(module2);
+  const request = getWebpackDependencyRequest(dep);
+  return graph.getDependencies().find(
+    (item) => item.module.path === modulePath && item.request === request
+  );
+}
+function getExportStatement(info, normalModule, graph) {
+  const webpackDependency = getExportDependency(info, normalModule);
+  if (!webpackDependency) {
+    return;
+  }
+  const modulePath = getWebpackModulePath(normalModule);
+  const request = getWebpackDependencyRequest(webpackDependency);
+  const sdkDependency = graph.getDependencies().find(
+    (item) => item.module.path === modulePath && item.request === request
+  );
+  if (sdkDependency && sdkDependency.statements.length === 1) {
+    return sdkDependency.statements[0];
+  }
+  const sdkModule = graph.getModuleByWebpackId(
+    getWebpackModuleId(normalModule)
+  );
+  if (sdkModule) {
+    return getDependencyPosition(webpackDependency, sdkModule);
+  }
+}
+function getLastExportInfo(info, webpackGraph) {
+  const target = info.findTarget(webpackGraph, () => true);
+  if (!target || !target.export) {
+    return;
+  }
+  const exportsInfo = webpackGraph.getExportsInfo(target.module);
+  const lastInfo = exportsInfo.getExportInfo(target.export[0]);
+  return lastInfo;
+}
+function getAllModules(compilation) {
+  const modules = [];
+  for (const mod of compilation.modules) {
+    modules.push(...mod.modules ?? []);
+    modules.push(mod);
+  }
+  return (0, import_lodash.unionBy)(
+    modules.filter(
+      (mod) => !getWebpackModuleId(mod).startsWith("webpack/runtime")
+    ),
+    (mod) => getWebpackModuleId(mod)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAllModules,
+  getDependencyPosition,
+  getEntryModule,
+  getExportDependency,
+  getExportStatement,
+  getLastExportInfo,
+  getModuleExportsType,
+  getModuleSource,
+  getResolveModule,
+  getResolveRequest,
+  getSdkDependencyByWebpackDependency,
+  getWebpackDependencyRequest,
+  getWebpackModuleId,
+  getWebpackModulePath,
+  isExternalModule,
+  isNormalModule
+});

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

@@ -0,0 +1,2 @@
+export * as Build from './build';
+export * as Common from './common';

package/dist/build-utils/index.js

@@ -0,0 +1,41 @@
+"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 build_utils_exports = {};
+__export(build_utils_exports, {
+  Build: () => Build,
+  Common: () => Common
+});
+module.exports = __toCommonJS(build_utils_exports);
+var Build = __toESM(require("./build"));
+var Common = __toESM(require("./common"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Build,
+  Common
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './build-utils';
+export * as InnerPlugins from './inner-plugins';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,43 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  InnerPlugins: () => InnerPlugins
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./build-utils"), module.exports);
+var InnerPlugins = __toESM(require("./inner-plugins"));
+__reExport(src_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InnerPlugins,
+  ...require("./build-utils"),
+  ...require("./types")
+});

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

@@ -0,0 +1,6 @@
+import type { Tap } from 'tapable';
+export declare const pluginTapName = "RsdoctorWebpackPlugin";
+export declare const pluginTapPostOptions: Tap;
+export declare const pluginTapPreOptions: Tap;
+export declare const internalPluginTapPreOptions: (namespace: string) => Tap;
+export declare const internalPluginTapPostOptions: (namespace: string) => Tap;

package/dist/inner-plugins/constants.js

@@ -0,0 +1,52 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  internalPluginTapPostOptions: () => internalPluginTapPostOptions,
+  internalPluginTapPreOptions: () => internalPluginTapPreOptions,
+  pluginTapName: () => pluginTapName,
+  pluginTapPostOptions: () => pluginTapPostOptions,
+  pluginTapPreOptions: () => pluginTapPreOptions
+});
+module.exports = __toCommonJS(constants_exports);
+const pluginTapName = "RsdoctorWebpackPlugin";
+const pluginTapPostOptions = {
+  name: pluginTapName,
+  stage: 999
+};
+const pluginTapPreOptions = {
+  name: pluginTapName,
+  stage: -999
+};
+const internalPluginTapPreOptions = (namespace) => ({
+  name: `${pluginTapName}:${namespace}`,
+  stage: -998
+});
+const internalPluginTapPostOptions = (namespace) => ({
+  name: `${pluginTapName}:${namespace}`,
+  stage: 1e3
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  internalPluginTapPostOptions,
+  internalPluginTapPreOptions,
+  pluginTapName,
+  pluginTapPostOptions,
+  pluginTapPreOptions
+});

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

@@ -0,0 +1,2 @@
+export * from './plugins';
+export * from './utils';

package/dist/inner-plugins/index.js

@@ -0,0 +1,24 @@
+"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 inner_plugins_exports = {};
+module.exports = __toCommonJS(inner_plugins_exports);
+__reExport(inner_plugins_exports, require("./plugins"), module.exports);
+__reExport(inner_plugins_exports, require("./utils"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./plugins"),
+  ...require("./utils")
+});

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

@@ -0,0 +1,4 @@
+import { Plugin } from '@rsdoctor/types';
+import type { ProxyLoaderOptions } from "../../types";
+declare const loaderModule: Plugin.LoaderDefinition<ProxyLoaderOptions, {}>;
+export = loaderModule;

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

@@ -0,0 +1,115 @@
+"use strict";
+var import_build = require("../../build-utils/build");
+var import_utils = require("../utils");
+const loaderModule = function(...args) {
+  if ((0, import_utils.shouldSkipLoader)(this)) {
+    this.callback(null, ...args);
+    return;
+  }
+  this.cacheable(false);
+  const mod = (0, import_utils.getOriginLoaderModule)(this);
+  if (mod.default) {
+    if (mod.raw === false && Buffer.isBuffer(args[0])) {
+      args[0] = args[0].toString();
+    }
+    let start;
+    let startHRTime;
+    const trap = import_build.Utils.createLoaderContextTrap.call(
+      this,
+      (err, res, sourceMap) => {
+        (0, import_utils.reportLoader)(
+          this,
+          start,
+          startHRTime,
+          false,
+          false,
+          args[0].toString(),
+          err,
+          res,
+          sourceMap
+        );
+      }
+    );
+    start = Date.now();
+    startHRTime = process.hrtime();
+    try {
+      const result = mod.default.apply(trap, args);
+      if (result) {
+        if (!(result instanceof Promise)) {
+          (0, import_utils.reportLoader)(
+            this,
+            start,
+            startHRTime,
+            false,
+            true,
+            args[0].toString(),
+            null,
+            result
+          );
+        }
+      }
+      return result;
+    } catch (error) {
+      (0, import_utils.reportLoader)(
+        this,
+        start,
+        startHRTime,
+        false,
+        true,
+        args[0].toString(),
+        error,
+        null
+      );
+      throw error;
+    }
+  }
+  this.callback(null, ...args);
+};
+loaderModule.pitch = function() {
+  if ((0, import_utils.shouldSkipLoader)(this)) {
+    return;
+  }
+  this.cacheable(false);
+  const mod = (0, import_utils.getOriginLoaderModule)(this);
+  if (mod.pitch && typeof mod.pitch === "function") {
+    let start;
+    let startHRTime;
+    const trap = import_build.Utils.createLoaderContextTrap.call(this, (err, res) => {
+      (0, import_utils.reportLoader)(
+        this,
+        start,
+        startHRTime,
+        true,
+        false,
+        err ? "Loader Pitch Async Error" : "",
+        err,
+        res
+      );
+    });
+    start = Date.now();
+    startHRTime = process.hrtime();
+    try {
+      const res = mod.pitch.apply(trap, arguments);
+      if (res) {
+        if (!(res instanceof Promise)) {
+          (0, import_utils.reportLoader)(this, start, startHRTime, true, true, "", null, res);
+        }
+      }
+      return res;
+    } catch (error) {
+      (0, import_utils.reportLoader)(
+        this,
+        start,
+        startHRTime,
+        true,
+        true,
+        "Loader Pitch Sync Error",
+        error,
+        null
+      );
+      throw error;
+    }
+  }
+};
+loaderModule.raw = true;
+module.exports = loaderModule;

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

@@ -0,0 +1,13 @@
+import type { DoctorWebpackSDK } from '@rsdoctor/sdk';
+import type { Linter, Plugin } from '@rsdoctor/types';
+import type { InternalPlugin, DoctorPluginInstance } from "../../types";
+export declare abstract class InternalBasePlugin<T extends Plugin.BaseCompiler> implements InternalPlugin<T, Linter.ExtendRuleData[]> {
+  readonly scheduler: DoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>;
+  abstract name: string;
+  constructor(scheduler: DoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>);
+  abstract apply(compiler: T): void;
+  get options(): import("@/types").DoctorPluginOptionsNormalized<Linter.ExtendRuleData<any, string>[]>;
+  get sdk(): DoctorWebpackSDK;
+  get tapPostOptions(): import("tapable").Tap;
+  get tapPreOptions(): import("tapable").Tap;
+}

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

@@ -0,0 +1,45 @@
+"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 base_exports = {};
+__export(base_exports, {
+  InternalBasePlugin: () => InternalBasePlugin
+});
+module.exports = __toCommonJS(base_exports);
+var import_constants = require("../constants");
+class InternalBasePlugin {
+  constructor(scheduler) {
+    this.scheduler = scheduler;
+  }
+  get options() {
+    return this.scheduler.options;
+  }
+  get sdk() {
+    return this.scheduler.sdk;
+  }
+  get tapPostOptions() {
+    return (0, import_constants.internalPluginTapPostOptions)(this.name);
+  }
+  get tapPreOptions() {
+    return (0, import_constants.internalPluginTapPreOptions)(this.name);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalBasePlugin
+});

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

@@ -0,0 +1,11 @@
+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>;
+}

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,6 @@
+export * from './loader';
+export * from './plugins';
+export * from './errors';
+export * from './progress';
+export * from './summary';
+export * from './base';