@rsdoctor/core 0.0.2-beta.0

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

@@ -0,0 +1,32 @@
+"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);
+// 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")
+});

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

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

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

@@ -0,0 +1,157 @@
+"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.DoctorManifestClientRoutes.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 || [];
+      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);
+      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 && compiler.webpack.NormalModule && 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
+});

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

@@ -0,0 +1,8 @@
+import { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalPluginsPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+  readonly name = "plugins";
+  apply(compiler: T): void;
+  afterPlugins: (compiler: Plugin.BaseCompiler) => void;
+  compilation: (compilation: Plugin.BaseCompilation) => void;
+}

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

@@ -0,0 +1,60 @@
+"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 plugins_exports = {};
+__export(plugins_exports, {
+  InternalPluginsPlugin: () => InternalPluginsPlugin
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_types = require("@rsdoctor/types");
+var import_build = require("../../build-utils/build");
+var import_utils = require("../utils");
+var import_base = require("./base");
+class InternalPluginsPlugin extends import_base.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "plugins";
+    this.afterPlugins = (compiler) => {
+      if (compiler.isChild())
+        return;
+      import_build.Utils.interceptCompilerHooks(
+        compiler,
+        (name, hook) => (0, import_utils.interceptPluginHook)(this.sdk, name, hook)
+      );
+      this.sdk.addClientRoutes([
+        import_types.Manifest.DoctorManifestClientRoutes.WebpackPlugins
+      ]);
+    };
+    this.compilation = (compilation) => {
+      if (compilation.compiler.isChild())
+        return;
+      import_build.Utils.interceptCompilationHooks(
+        compilation,
+        (name, hook) => (0, import_utils.interceptPluginHook)(this.sdk, name, hook)
+      );
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins);
+    compiler.hooks.compilation.tap(this.tapPostOptions, this.compilation);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalPluginsPlugin
+});

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

@@ -0,0 +1,8 @@
+import { SDK } from '@rsdoctor/types';
+import type { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalProgressPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+  readonly name = "progress";
+  protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgess>;
+  apply(compiler: T): void;
+}

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

@@ -0,0 +1,59 @@
+"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 progress_exports = {};
+__export(progress_exports, {
+  InternalProgressPlugin: () => InternalProgressPlugin
+});
+module.exports = __toCommonJS(progress_exports);
+var import_types = require("@rsdoctor/types");
+var import_base = require("./base");
+class InternalProgressPlugin extends import_base.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "progress";
+    this.currentProgress = {
+      percentage: 100,
+      message: ""
+    };
+  }
+  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 = import_types.SDK.ServerAPI.APIExtends.GetCompileProgess;
+          sdk.server.sendAPIDataToClient(api, {
+            req: {
+              api,
+              body: void 0
+            },
+            res: currentProgress
+          });
+        }
+      });
+      progress.apply(compiler);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalProgressPlugin
+});

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

@@ -0,0 +1,14 @@
+import type { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalSummaryPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+  readonly name = "summary";
+  private times;
+  private preTimes;
+  private postTimes;
+  apply(compiler: Plugin.BaseCompiler): void;
+  private mark;
+  beforeCompile: () => Promise<void>;
+  afterCompile: (compilation: Plugin.BaseCompilation) => Promise<void>;
+  done: (compiler: Plugin.BaseCompiler) => Promise<void>;
+  private report;
+}

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

@@ -0,0 +1,115 @@
+"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 summary_exports = {};
+__export(summary_exports, {
+  InternalSummaryPlugin: () => InternalSummaryPlugin
+});
+module.exports = __toCommonJS(summary_exports);
+var import_common = require("@rsdoctor/utils/common");
+var import_lodash = require("lodash");
+var import_base = require("./base");
+class InternalSummaryPlugin extends import_base.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "summary";
+    this.times = /* @__PURE__ */ new Map();
+    this.preTimes = /* @__PURE__ */ new Map();
+    this.postTimes = /* @__PURE__ */ new Map();
+    this.beforeCompile = async () => {
+      if (!this.times.has(import_common.Summary.SummaryCostsDataName.Bootstrap)) {
+        const costs = Math.floor(process.uptime() * 1e3);
+        const startAt = Date.now() - costs;
+        this.report(import_common.Summary.SummaryCostsDataName.Bootstrap, startAt);
+        this.mark(import_common.Summary.SummaryCostsDataName.Bootstrap, "post");
+      }
+    };
+    this.afterCompile = async (compilation) => {
+      if (!this.times.has(import_common.Summary.SummaryCostsDataName.Compile) && !compilation.compiler.isChild()) {
+        const start = this.postTimes.get(import_common.Summary.SummaryCostsDataName.Bootstrap);
+        this.report(import_common.Summary.SummaryCostsDataName.Compile, start);
+        this.mark(import_common.Summary.SummaryCostsDataName.Compile, "post");
+      }
+    };
+    this.done = async (compiler) => {
+      const start = this.postTimes.get(import_common.Summary.SummaryCostsDataName.Compile);
+      this.report(import_common.Summary.SummaryCostsDataName.Done, start);
+      if (compiler.options.optimization.minimize !== false) {
+        const pluginData = this.sdk.getStoreData().plugin;
+        const minifyHookData = [
+          ...pluginData.optimizeChunkAssets || [],
+          // webpack4
+          ...pluginData.processAssets || []
+          // webpack5
+        ];
+        minifyHookData.length && this.sdk.reportSummaryData({
+          costs: [
+            {
+              name: import_common.Summary.SummaryCostsDataName.Minify,
+              startAt: (0, import_lodash.minBy)(minifyHookData, (e) => e.startAt).startAt,
+              costs: (0, import_lodash.sumBy)(minifyHookData, (e) => e.costs)
+            }
+          ]
+        });
+      }
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.beforeCompile.tapPromise(
+      this.tapPostOptions,
+      this.beforeCompile
+    );
+    compiler.hooks.afterCompile.tapPromise(
+      this.tapPreOptions,
+      this.afterCompile
+    );
+    compiler.hooks.done.tapPromise(
+      this.tapPostOptions,
+      this.done.bind(this, compiler)
+    );
+  }
+  mark(key, type) {
+    const now = Date.now();
+    switch (type) {
+      case "pre":
+        this.preTimes.set(key, now);
+        break;
+      case "post":
+        this.postTimes.set(key, now);
+        break;
+      default:
+        break;
+    }
+  }
+  report(name, start) {
+    this.times.set(name, start);
+    this.sdk.reportSummaryData({
+      costs: [
+        {
+          name,
+          startAt: start,
+          costs: Date.now() - start
+        }
+      ]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalSummaryPlugin
+});

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

@@ -0,0 +1,4 @@
+export declare const checkCirclePath: (obj: any, record: {
+  prop: string;
+  ref: unknown;
+}[], res: string[][], level: number, maxLevel?: number) => void;

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

@@ -0,0 +1,42 @@
+"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 circleDetect_exports = {};
+__export(circleDetect_exports, {
+  checkCirclePath: () => checkCirclePath
+});
+module.exports = __toCommonJS(circleDetect_exports);
+const checkCirclePath = (obj, record, res, level, maxLevel = 3) => {
+  const idx = record.slice(0, record.length - 1).findIndex((v) => v.ref === obj);
+  if (idx !== -1) {
+    const key = record.map((v) => v.prop);
+    if (res.indexOf(key) < 0) {
+      res.push(key);
+      return;
+    }
+  }
+  if (typeof obj === "object" && obj !== null && level < maxLevel) {
+    for (const [k, v] of Object.entries(obj)) {
+      checkCirclePath(v, [...record, { prop: k, ref: v }], res, level + 1);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkCirclePath
+});

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

@@ -0,0 +1,7 @@
+import { Linter, Plugin } from '@rsdoctor/types';
+import { RuleSetCondition as RspackRuleSetCondition } from '@rspack/core';
+import { RuleSetCondition, RuleSetConditionAbsolute, RuleSetRule } from 'webpack';
+import { DoctorWebpackPluginOptions, DoctorPluginOptionsNormalized } from "../../types";
+export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: DoctorWebpackPluginOptions<Rules>): DoctorPluginOptionsNormalized<Rules>;
+export declare function makeRuleSetSerializable(item: RuleSetConditionAbsolute | RuleSetCondition | RspackRuleSetCondition | void): void;
+export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RuleSetRule['oneOf']): void;

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

@@ -0,0 +1,145 @@
+"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 config_exports = {};
+__export(config_exports, {
+  makeRuleSetSerializable: () => makeRuleSetSerializable,
+  makeRulesSerializable: () => makeRulesSerializable,
+  normalizeUserConfig: () => normalizeUserConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_types = require("@rsdoctor/types");
+var import_assert = __toESM(require("assert"));
+function defaultBoolean(v, dft) {
+  return typeof v === "boolean" ? v : dft;
+}
+function normalizeUserConfig(config = {}) {
+  const {
+    linter = {},
+    features = {},
+    loaderInterceptorOptions = {},
+    disableClientServer = false,
+    sdkInstance,
+    reportCodeType = { noModuleSource: false, noAssetsAndModuleSource: false },
+    disableTOSUpload = false
+  } = config;
+  (0, import_assert.default)(linter && typeof linter === "object");
+  (0, import_assert.default)(features && typeof features === "object");
+  (0, import_assert.default)(
+    loaderInterceptorOptions && typeof loaderInterceptorOptions === "object"
+  );
+  (0, import_assert.default)(typeof disableClientServer === "boolean");
+  const _features = Array.isArray(
+    features
+  ) ? {
+    loader: features.includes("loader"),
+    plugins: features.includes("plugins"),
+    resolver: features.includes("resolver"),
+    bundle: features.includes("bundle"),
+    treeShaking: features.includes("treeShaking"),
+    lite: features.includes("lite")
+  } : {
+    loader: defaultBoolean(features.loader, true),
+    plugins: defaultBoolean(features.plugins, true),
+    resolver: defaultBoolean(features.resolver, false),
+    bundle: defaultBoolean(features.bundle, true),
+    treeShaking: defaultBoolean(features.treeShaking, false),
+    lite: defaultBoolean(features.lite, false)
+  };
+  const _linter = {
+    rules: {},
+    extends: [],
+    level: "Error",
+    ...linter
+  };
+  const res = {
+    linter: _linter,
+    features: _features,
+    loaderInterceptorOptions: {
+      skipLoaders: Array.isArray(loaderInterceptorOptions.skipLoaders) ? loaderInterceptorOptions.skipLoaders : []
+    },
+    disableClientServer,
+    sdkInstance,
+    /**
+     * Data storage is divided into three types:
+     * The first type: normal mode, all codes are saved.
+     * The second type: lite is the same as reportCodeType.noModuleSource, which lacks module source code.
+     * The third type: reportCodeType.noAssetsAndModuleSource means there is no module source code nor the packaged product code.
+     *
+     *  */
+    reportCodeType: reportCodeType ? reportCodeType.noModuleSource ? import_types.SDK.ToDataType.Lite : reportCodeType.noAssetsAndModuleSource ? import_types.SDK.ToDataType.LiteAndNoAsset : import_types.SDK.ToDataType.Normal : _features.lite ? import_types.SDK.ToDataType.Lite : import_types.SDK.ToDataType.Normal,
+    disableTOSUpload
+  };
+  return res;
+}
+function makeRuleSetSerializable(item) {
+  if (!item)
+    return;
+  if (item instanceof RegExp) {
+    item.toJSON = item.toString;
+  } else if (Array.isArray(item)) {
+    item.forEach((i) => makeRuleSetSerializable(i));
+  } else if (typeof item === "object") {
+    makeRuleSetSerializable(item.and);
+    makeRuleSetSerializable(item.or);
+    makeRuleSetSerializable(item.not);
+  }
+}
+function makeRulesSerializable(rules) {
+  if (!Array.isArray(rules))
+    return;
+  if (!rules.length)
+    return;
+  rules.forEach((rule) => {
+    if (!rule)
+      return;
+    makeRuleSetSerializable(rule.test);
+    makeRuleSetSerializable(rule.resourceQuery);
+    makeRuleSetSerializable(rule.resource);
+    makeRuleSetSerializable(rule.resourceFragment);
+    makeRuleSetSerializable(rule.scheme);
+    makeRuleSetSerializable(rule.issuer);
+    if ("issuerLayer" in rule) {
+      makeRuleSetSerializable(rule.issuerLayer);
+    }
+    makeRuleSetSerializable(rule.include);
+    makeRuleSetSerializable(rule.exclude);
+    if (rule.oneOf) {
+      makeRulesSerializable(rule.oneOf);
+    }
+    if ("rules" in rule && rule.rules) {
+      makeRulesSerializable(rule.rules);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeRuleSetSerializable,
+  makeRulesSerializable,
+  normalizeUserConfig
+});

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

@@ -0,0 +1,5 @@
+export * from './loader';
+export * from './plugin';
+export * from './sdk';
+export * from './config';
+export * from './circleDetect';