@rsdoctor/core 1.2.2 → 1.2.4-beta.0

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

@@ -1,44 +1,18 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    InternalSummaryPlugin: ()=>InternalSummaryPlugin
-});
-const common_namespaceObject = require("@rsdoctor/utils/common");
-const external_lodash_namespaceObject = require("lodash");
-const external_base_js_namespaceObject = require("./base.js");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
-class InternalSummaryPlugin extends external_base_js_namespaceObject.InternalBasePlugin {
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { Summary } from "@rsdoctor/utils/common";
+import { minBy, sumBy } from "lodash-es";
+import { InternalBasePlugin } from "./base.js";
+import { time, timeEnd } from "@rsdoctor/utils/logger";
+class InternalSummaryPlugin extends InternalBasePlugin {
     apply(compiler) {
-        (0, logger_namespaceObject.time)('InternalSummaryPlugin.apply');
+        time('InternalSummaryPlugin.apply');
         try {
             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));
         } finally{
-            (0, logger_namespaceObject.timeEnd)('InternalSummaryPlugin.apply');
+            timeEnd('InternalSummaryPlugin.apply');
         }
     }
     mark(key, type) {
@@ -68,33 +42,33 @@ class InternalSummaryPlugin extends external_base_js_namespaceObject.InternalBas
     }
     constructor(...args){
         super(...args), this.name = 'summary', this.times = new Map(), this.preTimes = new Map(), this.postTimes = new Map(), this.beforeCompile = async ()=>{
-            (0, logger_namespaceObject.time)('InternalSummaryPlugin.beforeCompile');
+            time('InternalSummaryPlugin.beforeCompile');
             try {
-                if (!this.times.has(common_namespaceObject.Summary.SummaryCostsDataName.Bootstrap)) {
+                if (!this.times.has(Summary.SummaryCostsDataName.Bootstrap)) {
                     const costs = Math.floor(1000 * process.uptime());
                     const startAt = Date.now() - costs;
-                    this.report(common_namespaceObject.Summary.SummaryCostsDataName.Bootstrap, startAt);
-                    this.mark(common_namespaceObject.Summary.SummaryCostsDataName.Bootstrap, 'post');
+                    this.report(Summary.SummaryCostsDataName.Bootstrap, startAt);
+                    this.mark(Summary.SummaryCostsDataName.Bootstrap, 'post');
                 }
             } finally{
-                (0, logger_namespaceObject.timeEnd)('InternalSummaryPlugin.beforeCompile');
+                timeEnd('InternalSummaryPlugin.beforeCompile');
             }
         }, this.afterCompile = async (compilation)=>{
-            (0, logger_namespaceObject.time)('InternalSummaryPlugin.afterCompile');
+            time('InternalSummaryPlugin.afterCompile');
             try {
-                if (!this.times.has(common_namespaceObject.Summary.SummaryCostsDataName.Compile) && !compilation.compiler.isChild()) {
-                    const start = this.postTimes.get(common_namespaceObject.Summary.SummaryCostsDataName.Bootstrap);
-                    this.report(common_namespaceObject.Summary.SummaryCostsDataName.Compile, start);
-                    this.mark(common_namespaceObject.Summary.SummaryCostsDataName.Compile, 'post');
+                if (!this.times.has(Summary.SummaryCostsDataName.Compile) && !compilation.compiler.isChild()) {
+                    const start = this.postTimes.get(Summary.SummaryCostsDataName.Bootstrap);
+                    this.report(Summary.SummaryCostsDataName.Compile, start);
+                    this.mark(Summary.SummaryCostsDataName.Compile, 'post');
                 }
             } finally{
-                (0, logger_namespaceObject.timeEnd)('InternalSummaryPlugin.afterCompile');
+                timeEnd('InternalSummaryPlugin.afterCompile');
             }
         }, this.done = async (compiler)=>{
-            (0, logger_namespaceObject.time)('InternalSummaryPlugin.done');
+            time('InternalSummaryPlugin.done');
             try {
-                const start = this.postTimes.get(common_namespaceObject.Summary.SummaryCostsDataName.Compile);
-                this.report(common_namespaceObject.Summary.SummaryCostsDataName.Done, start);
+                const start = this.postTimes.get(Summary.SummaryCostsDataName.Compile);
+                this.report(Summary.SummaryCostsDataName.Done, start);
                 if (false !== compiler.options.optimization.minimize) {
                     const pluginData = this.sdk.getStoreData().plugin;
                     const minifyHookData = [
@@ -103,23 +77,17 @@ class InternalSummaryPlugin extends external_base_js_namespaceObject.InternalBas
                     minifyHookData.length && this.sdk.reportSummaryData({
                         costs: [
                             {
-                                name: common_namespaceObject.Summary.SummaryCostsDataName.Minify,
-                                startAt: (0, external_lodash_namespaceObject.minBy)(minifyHookData, (e)=>e.startAt).startAt,
-                                costs: (0, external_lodash_namespaceObject.sumBy)(minifyHookData, (e)=>e.costs)
+                                name: Summary.SummaryCostsDataName.Minify,
+                                startAt: minBy(minifyHookData, (e)=>e.startAt).startAt,
+                                costs: sumBy(minifyHookData, (e)=>e.costs)
                             }
                         ]
                     });
                 }
             } finally{
-                (0, logger_namespaceObject.timeEnd)('InternalSummaryPlugin.done');
+                timeEnd('InternalSummaryPlugin.done');
             }
         };
     }
 }
-exports.InternalSummaryPlugin = __webpack_exports__.InternalSummaryPlugin;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "InternalSummaryPlugin"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { InternalSummaryPlugin };

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

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    checkCirclePath: ()=>checkCirclePath
+});
+const checkCirclePath = (obj, record, res, level, maxLevel = 3)=>{
+    const idx = record.slice(0, record.length - 1).findIndex((v)=>v.ref === obj);
+    if (-1 !== idx) {
+        const key = record.map((v)=>v.prop);
+        if (res.indexOf(key) < 0) return void res.push(key);
+    }
+    if ('object' == typeof obj && null !== obj && level < maxLevel) for (const [k, v] of Object.entries(obj))checkCirclePath(v, [
+        ...record,
+        {
+            prop: k,
+            ref: v
+        }
+    ], res, level + 1);
+};
+exports.checkCirclePath = __webpack_exports__.checkCirclePath;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "checkCirclePath"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -2,4 +2,3 @@ export declare const checkCirclePath: (obj: any, record: {
     prop: string;
     ref: unknown;
 }[], res: string[][], level: number, maxLevel?: number) => void;
-//# sourceMappingURL=circleDetect.d.ts.map

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

@@ -1,31 +1,5 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    checkCirclePath: ()=>checkCirclePath
-});
+import 'module';
+/*#__PURE__*/ import.meta.url;
 const checkCirclePath = (obj, record, res, level, maxLevel = 3)=>{
     const idx = record.slice(0, record.length - 1).findIndex((v)=>v.ref === obj);
     if (-1 !== idx) {
@@ -40,10 +14,4 @@ const checkCirclePath = (obj, record, res, level, maxLevel = 3)=>{
         }
     ], res, level + 1);
 };
-exports.checkCirclePath = __webpack_exports__.checkCirclePath;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "checkCirclePath"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { checkCirclePath };

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

@@ -0,0 +1,177 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizeUserConfig: ()=>normalizeUserConfig,
+    normalizeReportType: ()=>normalizeReportType,
+    normalizeRspackUserOptions: ()=>normalizeRspackUserOptions
+});
+const types_namespaceObject = require("@rsdoctor/types");
+const logger_namespaceObject = require("@rsdoctor/utils/logger");
+const external_assert_namespaceObject = require("assert");
+var external_assert_default = /*#__PURE__*/ __webpack_require__.n(external_assert_namespaceObject);
+const external_normalize_config_cjs_namespaceObject = require("./normalize-config.cjs");
+function defaultBoolean(v, dft) {
+    return 'boolean' == typeof v ? v : dft;
+}
+function getDefaultOutput() {
+    return {
+        mode: void 0,
+        reportCodeType: {
+            noModuleSource: false,
+            noAssetsAndModuleSource: false,
+            noCode: false
+        },
+        options: void 0,
+        reportDir: '',
+        compressData: void 0
+    };
+}
+function getDefaultSupports() {
+    return {
+        parseBundle: true,
+        banner: void 0,
+        gzip: true
+    };
+}
+function normalizeFeatures(features, mode) {
+    if (Array.isArray(features)) return {
+        loader: features.includes('loader'),
+        plugins: features.includes('plugins'),
+        resolver: features.includes('resolver'),
+        bundle: features.includes('bundle'),
+        treeShaking: features.includes('treeShaking'),
+        lite: features.includes('lite') || mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite]
+    };
+    return {
+        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) || mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite]
+    };
+}
+function normalizeLinter(linter) {
+    return {
+        rules: {},
+        extends: [],
+        level: 'Error',
+        ...linter
+    };
+}
+function isValidMode(mode) {
+    return 'string' == typeof mode && [
+        'brief',
+        'normal',
+        'lite'
+    ].includes(mode);
+}
+function normalizeUserConfig(config = {}) {
+    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer = false, sdkInstance, innerClientPath = '', output = getDefaultOutput(), supports = getDefaultSupports(), port, printLog = {
+        serverUrls: true
+    }, mode, brief } = config;
+    external_assert_default()('object' == typeof linter);
+    external_assert_default()('object' == typeof features || Array.isArray(features));
+    external_assert_default()('object' == typeof loaderInterceptorOptions);
+    external_assert_default()('boolean' == typeof disableClientServer);
+    let finalMode = ('mode' in output && isValidMode(output.mode) ? 'lite' === output.mode ? types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.normal] : output.mode : void 0) || mode || types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.normal];
+    if (mode) logger_namespaceObject.logger.info(logger_namespaceObject.chalk.yellow("The 'mode' configuration will be deprecated in a future version. Please use 'output.mode' instead."));
+    const _features = normalizeFeatures(features, finalMode);
+    const _linter = normalizeLinter(linter);
+    if (_features.lite || finalMode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite]) logger_namespaceObject.logger.info(logger_namespaceObject.chalk.yellow("Lite features will be deprecated in a future version. Please use 'output: { reportCodeType: { noAssetsAndModuleSource: true }}' instead."));
+    const { finalBrief, finalNormalOptions } = (0, external_normalize_config_cjs_namespaceObject.processModeConfigurations)(finalMode, output, brief);
+    if (_features.lite && finalMode !== types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.brief]) finalMode = types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite];
+    const reportCodeType = output.reportCodeType ? normalizeReportType(output.reportCodeType, finalMode) : normalizeReportType(getDefaultOutput().reportCodeType, finalMode);
+    const res = {
+        linter: _linter,
+        features: _features,
+        loaderInterceptorOptions: {
+            skipLoaders: Array.isArray(loaderInterceptorOptions.skipLoaders) ? loaderInterceptorOptions.skipLoaders : []
+        },
+        disableClientServer,
+        sdkInstance,
+        output: {
+            mode: finalMode,
+            options: 'brief' === finalMode ? finalBrief : finalNormalOptions,
+            reportCodeType,
+            reportDir: output.reportDir || ''
+        },
+        innerClientPath,
+        supports,
+        port,
+        printLog
+    };
+    if (void 0 !== output.compressData) logger_namespaceObject.logger.info(logger_namespaceObject.chalk.yellow("The 'compressData' configuration will be deprecated in a future version."));
+    return res;
+}
+const normalizeReportType = (reportCodeType, mode)=>{
+    const convertedReportCodeType = 'object' == typeof reportCodeType ? (0, external_normalize_config_cjs_namespaceObject.convertReportCodeTypeObject)(reportCodeType) : reportCodeType;
+    if ('noCode' === convertedReportCodeType) return types_namespaceObject.SDK.ToDataType.NoCode;
+    if (mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.brief]) return types_namespaceObject.SDK.ToDataType.NoCode;
+    if (mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite]) return types_namespaceObject.SDK.ToDataType.NoSourceAndAssets;
+    if ('noAssetsAndModuleSource' === convertedReportCodeType) return types_namespaceObject.SDK.ToDataType.NoSourceAndAssets;
+    if ('noModuleSource' === convertedReportCodeType) return types_namespaceObject.SDK.ToDataType.NoSource;
+    return types_namespaceObject.SDK.ToDataType.Normal;
+};
+function normalizeRspackUserOptions(options) {
+    var _options_experiments, _options_experiments1;
+    const config = normalizeUserConfig(options);
+    config.experiments ??= {
+        enableNativePlugin: {
+            moduleGraph: false,
+            chunkGraph: false
+        }
+    };
+    if ('boolean' == typeof (null == (_options_experiments = options.experiments) ? void 0 : _options_experiments.enableNativePlugin) && (null == (_options_experiments1 = options.experiments) ? void 0 : _options_experiments1.enableNativePlugin) === true) config.experiments.enableNativePlugin = {
+        moduleGraph: true,
+        chunkGraph: true
+    };
+    else config.experiments.enableNativePlugin = {
+        moduleGraph: false,
+        chunkGraph: false
+    };
+    return config;
+}
+exports.normalizeReportType = __webpack_exports__.normalizeReportType;
+exports.normalizeRspackUserOptions = __webpack_exports__.normalizeRspackUserOptions;
+exports.normalizeUserConfig = __webpack_exports__.normalizeUserConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "normalizeReportType",
+    "normalizeRspackUserOptions",
+    "normalizeUserConfig"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,10 +1,5 @@
+import { RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../../types';
 import { Linter, Plugin, SDK } from '@rsdoctor/types';
-import type { RuleSetCondition as RspackRuleSetCondition, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
-import { RuleSetCondition as WebpackRuleSetCondition, RuleSetConditionAbsolute as WebpackRuleSetConditionAbsolute, RuleSetRule as WebpackRuleSetRule } from 'webpack';
-import { RsdoctorWebpackPluginOptions, RsdoctorPluginOptionsNormalized, IReportCodeType, RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../../types';
-export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: RsdoctorWebpackPluginOptions<Rules>): RsdoctorPluginOptionsNormalized<Rules>;
-export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | WebpackRuleSetConditionAbsolute | WebpackRuleSetCondition | void): void;
-export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf'] | WebpackRuleSetRule['oneOf']): void;
-export declare const normalizeReportType: (reportCodeType: IReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
+export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorWebpackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
+export declare const normalizeReportType: (reportCodeType: Plugin.IReportCodeType | Plugin.NewReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
 export declare function normalizeRspackUserOptions<Rules extends Linter.ExtendRuleData[]>(options: RsdoctorRspackPluginOptions<Rules>): RsdoctorRspackPluginOptionsNormalized<Rules>;
-//# sourceMappingURL=config.d.ts.map

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

@@ -1,60 +1,23 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    normalizeUserConfig: ()=>normalizeUserConfig,
-    makeRuleSetSerializable: ()=>makeRuleSetSerializable,
-    makeRulesSerializable: ()=>makeRulesSerializable,
-    normalizeReportType: ()=>normalizeReportType,
-    normalizeRspackUserOptions: ()=>normalizeRspackUserOptions
-});
-const types_namespaceObject = require("@rsdoctor/types");
-const external_assert_namespaceObject = require("assert");
-var external_assert_default = /*#__PURE__*/ __webpack_require__.n(external_assert_namespaceObject);
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { SDK } from "@rsdoctor/types";
+import { chalk, logger } from "@rsdoctor/utils/logger";
+import assert from "assert";
+import { convertReportCodeTypeObject, processModeConfigurations } from "./normalize-config.js";
 function defaultBoolean(v, dft) {
     return 'boolean' == typeof v ? v : dft;
 }
 function getDefaultOutput() {
     return {
+        mode: void 0,
         reportCodeType: {
             noModuleSource: false,
             noAssetsAndModuleSource: false,
             noCode: false
         },
+        options: void 0,
         reportDir: '',
-        compressData: true
+        compressData: void 0
     };
 }
 function getDefaultSupports() {
@@ -71,7 +34,7 @@ function normalizeFeatures(features, mode) {
         resolver: features.includes('resolver'),
         bundle: features.includes('bundle'),
         treeShaking: features.includes('treeShaking'),
-        lite: features.includes('lite') || mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite]
+        lite: features.includes('lite') || mode === SDK.IMode[SDK.IMode.lite]
     };
     return {
         loader: defaultBoolean(features.loader, true),
@@ -79,7 +42,7 @@ function normalizeFeatures(features, mode) {
         resolver: defaultBoolean(features.resolver, false),
         bundle: defaultBoolean(features.bundle, true),
         treeShaking: defaultBoolean(features.treeShaking, false),
-        lite: defaultBoolean(features.lite, false) || mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite]
+        lite: defaultBoolean(features.lite, false) || mode === SDK.IMode[SDK.IMode.lite]
     };
 }
 function normalizeLinter(linter) {
@@ -90,23 +53,29 @@ function normalizeLinter(linter) {
         ...linter
     };
 }
+function isValidMode(mode) {
+    return 'string' == typeof mode && [
+        'brief',
+        'normal',
+        'lite'
+    ].includes(mode);
+}
 function normalizeUserConfig(config = {}) {
     const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer = false, sdkInstance, innerClientPath = '', output = getDefaultOutput(), supports = getDefaultSupports(), port, printLog = {
         serverUrls: true
-    }, mode = 'normal', brief = {
-        reportHtmlDir: void 0,
-        reportHtmlName: void 0,
-        writeDataJson: false
-    } } = config;
-    external_assert_default()('object' == typeof linter);
-    external_assert_default()('object' == typeof features || Array.isArray(features));
-    external_assert_default()('object' == typeof loaderInterceptorOptions);
-    external_assert_default()('boolean' == typeof disableClientServer);
-    const _features = normalizeFeatures(features, mode);
+    }, mode, brief } = config;
+    assert('object' == typeof linter);
+    assert('object' == typeof features || Array.isArray(features));
+    assert('object' == typeof loaderInterceptorOptions);
+    assert('boolean' == typeof disableClientServer);
+    let finalMode = ('mode' in output && isValidMode(output.mode) ? 'lite' === output.mode ? SDK.IMode[SDK.IMode.normal] : output.mode : void 0) || mode || SDK.IMode[SDK.IMode.normal];
+    if (mode) logger.info(chalk.yellow("The 'mode' configuration will be deprecated in a future version. Please use 'output.mode' instead."));
+    const _features = normalizeFeatures(features, finalMode);
     const _linter = normalizeLinter(linter);
-    let _mode = mode;
-    if (_features.lite && _mode !== types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.brief]) _mode = types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite];
-    const reportCodeType = output.reportCodeType ? normalizeReportType(output.reportCodeType, _mode) : normalizeReportType(getDefaultOutput().reportCodeType, _mode);
+    if (_features.lite || finalMode === SDK.IMode[SDK.IMode.lite]) logger.info(chalk.yellow("Lite features will be deprecated in a future version. Please use 'output: { reportCodeType: { noAssetsAndModuleSource: true }}' instead."));
+    const { finalBrief, finalNormalOptions } = processModeConfigurations(finalMode, output, brief);
+    if (_features.lite && finalMode !== SDK.IMode[SDK.IMode.brief]) finalMode = SDK.IMode[SDK.IMode.lite];
+    const reportCodeType = output.reportCodeType ? normalizeReportType(output.reportCodeType, finalMode) : normalizeReportType(getDefaultOutput().reportCodeType, finalMode);
     const res = {
         linter: _linter,
         features: _features,
@@ -116,55 +85,27 @@ function normalizeUserConfig(config = {}) {
         disableClientServer,
         sdkInstance,
         output: {
+            mode: finalMode,
+            options: 'brief' === finalMode ? finalBrief : finalNormalOptions,
             reportCodeType,
-            reportDir: output.reportDir || '',
-            compressData: void 0 !== output.compressData ? output.compressData : true
+            reportDir: output.reportDir || ''
         },
         innerClientPath,
         supports,
         port,
-        printLog,
-        mode,
-        brief
+        printLog
     };
-    if (false === res.output.compressData && (!output.reportCodeType || !output.reportCodeType.noAssetsAndModuleSource)) logger_namespaceObject.logger.info(logger_namespaceObject.chalk.yellow("[RSDOCTOR]: When you use compressData: false, it is recommended to set output.reportCodeType to { noAssetsAndModuleSource: true }."));
+    if (void 0 !== output.compressData) logger.info(chalk.yellow("The 'compressData' configuration will be deprecated in a future version."));
     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 ('object' == typeof item) {
-        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);
-    });
-}
 const normalizeReportType = (reportCodeType, mode)=>{
-    if (reportCodeType.noCode) return types_namespaceObject.SDK.ToDataType.NoCode;
-    if (mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.brief]) return types_namespaceObject.SDK.ToDataType.NoCode;
-    if (mode === types_namespaceObject.SDK.IMode[types_namespaceObject.SDK.IMode.lite]) return types_namespaceObject.SDK.ToDataType.NoSourceAndAssets;
-    if (reportCodeType.noAssetsAndModuleSource) return types_namespaceObject.SDK.ToDataType.NoSourceAndAssets;
-    if (reportCodeType.noModuleSource) return types_namespaceObject.SDK.ToDataType.NoSource;
-    return types_namespaceObject.SDK.ToDataType.Normal;
+    const convertedReportCodeType = 'object' == typeof reportCodeType ? convertReportCodeTypeObject(reportCodeType) : reportCodeType;
+    if ('noCode' === convertedReportCodeType) return SDK.ToDataType.NoCode;
+    if (mode === SDK.IMode[SDK.IMode.brief]) return SDK.ToDataType.NoCode;
+    if (mode === SDK.IMode[SDK.IMode.lite]) return SDK.ToDataType.NoSourceAndAssets;
+    if ('noAssetsAndModuleSource' === convertedReportCodeType) return SDK.ToDataType.NoSourceAndAssets;
+    if ('noModuleSource' === convertedReportCodeType) return SDK.ToDataType.NoSource;
+    return SDK.ToDataType.Normal;
 };
 function normalizeRspackUserOptions(options) {
     var _options_experiments, _options_experiments1;
@@ -185,18 +126,4 @@ function normalizeRspackUserOptions(options) {
     };
     return config;
 }
-exports.makeRuleSetSerializable = __webpack_exports__.makeRuleSetSerializable;
-exports.makeRulesSerializable = __webpack_exports__.makeRulesSerializable;
-exports.normalizeReportType = __webpack_exports__.normalizeReportType;
-exports.normalizeRspackUserOptions = __webpack_exports__.normalizeRspackUserOptions;
-exports.normalizeUserConfig = __webpack_exports__.normalizeUserConfig;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "makeRuleSetSerializable",
-    "makeRulesSerializable",
-    "normalizeReportType",
-    "normalizeRspackUserOptions",
-    "normalizeUserConfig"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { normalizeReportType, normalizeRspackUserOptions, normalizeUserConfig };