@rsdoctor/core 2.0.0-alpha.1 → 2.0.0-beta.0

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

@@ -1,92 +0,0 @@
-import "node:module";
-import { Summary } from "../../common/index.js";
-import { minBy, sumBy } from "../../collection.js";
-import { InternalBasePlugin } from "./base.js";
-import { time, timeEnd } from "../../logger.js";
-class InternalSummaryPlugin extends InternalBasePlugin {
-    apply(compiler) {
-        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{
-            timeEnd('InternalSummaryPlugin.apply');
-        }
-    }
-    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
-                }
-            ]
-        });
-    }
-    constructor(...args){
-        super(...args), this.name = 'summary', this.times = new Map(), this.preTimes = new Map(), this.postTimes = new Map(), this.beforeCompile = async ()=>{
-            time('InternalSummaryPlugin.beforeCompile');
-            try {
-                if (!this.times.has(Summary.SummaryCostsDataName.Bootstrap)) {
-                    const costs = Math.floor(1000 * process.uptime());
-                    const startAt = Date.now() - costs;
-                    this.report(Summary.SummaryCostsDataName.Bootstrap, startAt);
-                    this.mark(Summary.SummaryCostsDataName.Bootstrap, 'post');
-                }
-            } finally{
-                timeEnd('InternalSummaryPlugin.beforeCompile');
-            }
-        }, this.afterCompile = async (compilation)=>{
-            time('InternalSummaryPlugin.afterCompile');
-            try {
-                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{
-                timeEnd('InternalSummaryPlugin.afterCompile');
-            }
-        }, this.done = async (compiler)=>{
-            time('InternalSummaryPlugin.done');
-            try {
-                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 = [
-                        ...pluginData.processAssets || []
-                    ];
-                    if (minifyHookData.length) this.sdk.reportSummaryData({
-                        costs: [
-                            {
-                                name: Summary.SummaryCostsDataName.Minify,
-                                startAt: minBy(minifyHookData, (e)=>e.startAt).startAt,
-                                costs: sumBy(minifyHookData, (e)=>e.costs)
-                            }
-                        ]
-                    });
-                }
-            } finally{
-                timeEnd('InternalSummaryPlugin.done');
-            }
-        };
-    }
-}
-export { InternalSummaryPlugin };

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

@@ -1,16 +0,0 @@
-import "node:module";
-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);
-};
-export { checkCirclePath };

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

@@ -1,141 +0,0 @@
-import "node:module";
-import { SDK } from "@rsdoctor/shared/types";
-import { chalk, logger } from "../../logger.js";
-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: void 0
-    };
-}
-function getDefaultSupports() {
-    return {
-        parseBundle: true,
-        gzip: true
-    };
-}
-function isJsonOutputEnv(value) {
-    return 'json' === value;
-}
-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 === SDK.IMode[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 === SDK.IMode[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 userOutput = config.output;
-    const defaultOutput = getDefaultOutput();
-    const outputConfig = isJsonOutputEnv(process.env.RSDOCTOR_OUTPUT) ? {
-        reportDir: userOutput?.reportDir,
-        compressData: userOutput?.compressData,
-        mode: 'brief',
-        options: {
-            type: [
-                'json'
-            ]
-        }
-    } : userOutput ?? defaultOutput;
-    const normalizedConfig = {
-        ...config,
-        output: outputConfig
-    };
-    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = false, sdkInstance, innerClientPath = '', output = outputConfig, supports: userSupports = {}, port, server: userServer = {}, printLog = {
-        serverUrls: true
-    }, mode, brief } = normalizedConfig;
-    const supports = {
-        ...getDefaultSupports(),
-        ...userSupports
-    };
-    const disableClientServer = 'true' === process.env.RSTEST ? false : process.env.CI ? true : userDisableClientServer;
-    assert('object' == typeof linter);
-    assert('object' == typeof features || Array.isArray(features));
-    assert('object' == typeof loaderInterceptorOptions);
-    assert('boolean' == typeof disableClientServer);
-    assert(void 0 === port || 'number' == typeof port);
-    assert('object' == typeof userServer && null !== userServer);
-    const server = {
-        ...userServer
-    };
-    assert(void 0 === server.port || 'number' == typeof server.port);
-    if (void 0 === server.port && void 0 !== port) server.port = port;
-    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);
-    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,
-        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,
-        server,
-        printLog
-    };
-    if (void 0 !== output.compressData) logger.info(chalk.yellow("The 'compressData' configuration will be deprecated in a future version."));
-    return res;
-}
-const normalizeReportType = (reportCodeType, mode)=>{
-    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;
-};
-const normalizeRspackUserOptions = normalizeUserConfig;
-export { normalizeReportType, normalizeRspackUserOptions, normalizeUserConfig };

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

@@ -1,8 +0,0 @@
-import "node:module";
-export * from "./loader.js";
-export * from "./plugin.js";
-export * from "./sdk.js";
-export * from "./config.js";
-export * from "./circleDetect.js";
-export * from "./plugin-common.js";
-export * from "./normalize-config.js";

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

@@ -1,134 +0,0 @@
-import "node:module";
-import { omit } from "../../collection.js";
-import path from "path";
-import { logger } from "../../logger.js";
-import { Fetch, Loader, Lodash, Time } from "../../common/index.js";
-import { SDK } from "@rsdoctor/shared/types";
-import { DevToolError } from "../../error/index.js";
-import { getSDK } from "./sdk.js";
-import { checkCirclePath } from "./circleDetect.js";
-import { Utils } from "../../build-utils/build/index.js";
-import { isESMLoader, parseQuery } from "../../build-utils/build/utils/index.js";
-function getInternalLoaderOptions(loaderContext) {
-    const options = loaderContext.getOptions();
-    return options[Loader.LoaderInternalPropertyName];
-}
-function getLoaderOptionsWithoutInternalKeys(loaderContext) {
-    const options = loaderContext.getOptions();
-    const circlePaths = [];
-    const loaderOptions = omit(options, [
-        Loader.LoaderInternalPropertyName
-    ]);
-    checkCirclePath(loaderOptions, [], circlePaths, 0);
-    if (circlePaths.length > 0) circlePaths.forEach((_path)=>{
-        if (_path?.length > 0 && '[Circular]' !== loaderOptions[_path[0]]) loaderOptions[_path[0]] = '[Circular]';
-    });
-    return loaderOptions;
-}
-function getOriginLoaderModule(loaderContext) {
-    const { loader, cwd } = getInternalLoaderOptions(loaderContext);
-    return Utils.loadLoaderModule(loader, cwd);
-}
-function shouldSkipLoader(loaderContext) {
-    const { skipLoaders, cwd, loader } = getInternalLoaderOptions(loaderContext) || {};
-    if (!loader) return true;
-    if (Array.isArray(skipLoaders) && skipLoaders.length) {
-        if (skipLoaders.includes(loader)) return true;
-        const loaderName = Utils.extractLoaderName(loader, cwd);
-        if (skipLoaders.includes(loaderName)) return true;
-    }
-    return false;
-}
-function interceptLoader(rules, loaderPath, options, loaderResolver, cwd = process.cwd()) {
-    const resolve = (target)=>{
-        try {
-            const result = loaderResolver.resolveSync({}, cwd, target);
-            if (result) return result;
-        } catch  {}
-        return target;
-    };
-    return Utils.mapEachRules(rules, (rule)=>{
-        if (rule.loader?.startsWith('builtin:') || rule.loader?.endsWith('.mjs') || isESMLoader(rule)) return rule;
-        const opts = {
-            ...'options' in rule ? 'string' == typeof rule.options ? JSON.parse(rule.options) : rule.options : {}
-        };
-        opts[Loader.LoaderInternalPropertyName] = rule.loader && /proxy\.(js|cjs)/.test(rule.loader) && 'options' in rule && 'object' == typeof rule.options ? rule.options[Loader.LoaderInternalPropertyName] : {
-            ...options,
-            hasOptions: 'options' in rule && Boolean(rule.options),
-            loader: 'loader' in rule ? resolve(rule.loader) : ''
-        };
-        return {
-            ...rule,
-            loader: loaderPath,
-            options: opts
-        };
-    });
-}
-async function reportLoader(ctx, start, startHRTime, isPitch, sync, code, err, res, sourceMap) {
-    const end = Time.getCurrentTimestamp(start, startHRTime);
-    const { loader, host } = getInternalLoaderOptions(ctx);
-    const loaderData = [
-        {
-            resource: {
-                path: ctx._module?.layer ? `${ctx.resourcePath}[${ctx._module.layer}]` : ctx.resourcePath,
-                query: parseQuery(ctx.resourceQuery || '?'),
-                queryRaw: ctx.resourceQuery,
-                ext: path.extname(ctx.resourcePath).slice(1),
-                ...ctx._module?.layer ? {
-                    layer: ctx._module.layer
-                } : {}
-            },
-            loaders: [
-                {
-                    loader: Utils.extractLoaderName(loader),
-                    loaderIndex: ctx.loaderIndex,
-                    path: loader,
-                    input: code,
-                    result: 'string' == typeof res || Buffer.isBuffer(res) ? res.toString() : res,
-                    startAt: start,
-                    endAt: end,
-                    options: getLoaderOptionsWithoutInternalKeys(ctx),
-                    isPitch,
-                    sync,
-                    errors: err ? [
-                        new DevToolError(code, err.message, {
-                            controller: {
-                                noStack: false,
-                                noColor: true
-                            },
-                            stack: err.stack
-                        })
-                    ] : [],
-                    pid: process.pid,
-                    ppid: process.ppid
-                }
-            ]
-        }
-    ];
-    const data = sourceMap ? Lodash.isString(sourceMap) ? JSON.parse(sourceMap) : sourceMap : {};
-    const sourceMapData = {
-        version: data.version ?? -1,
-        sources: data.sources ?? [],
-        names: data.names ?? [],
-        sourceRoot: data.sourceRoot,
-        sourcesContent: data.sourcesContent,
-        mappings: data.mappings,
-        file: loaderData[0].resource.path
-    };
-    const sdk = getSDK(ctx._compilation?.name);
-    if (sdk?.reportLoader && !('parent' in sdk && sdk.parent)) {
-        sdk.reportLoader(loaderData);
-        sdk.reportSourceMap(sourceMapData);
-        return loaderData;
-    }
-    await Promise.all([
-        Fetch.postJSON(`${host}${SDK.ServerAPI.API.ReportLoader}`, loaderData, 8888).catch((err)=>{
-            logger.debug(`${err.message}`, '[RspackPlugin.ReportLoader][error]');
-        }),
-        Fetch.postJSON(`${host}${SDK.ServerAPI.API.ReportSourceMap}`, sourceMapData, 8888).catch((err)=>{
-            logger.debug(`${err.message}`, '[RspackPlugin.ReportSourceMap][error]');
-        })
-    ]);
-    return loaderData;
-}
-export { getInternalLoaderOptions, getLoaderOptionsWithoutInternalKeys, getOriginLoaderModule, interceptLoader, reportLoader, shouldSkipLoader };

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

@@ -1,77 +0,0 @@
-import "node:module";
-function processModeConfigurations(finalMode, output, brief) {
-    let finalBrief = {};
-    let finalNormalOptions = {};
-    if ('brief' === finalMode) finalBrief = processBriefHtmlModeConfig(output, brief);
-    else if ('normal' === finalMode) finalNormalOptions = {};
-    return {
-        finalBrief,
-        finalNormalOptions
-    };
-}
-function processBriefHtmlModeConfig(output, brief) {
-    let htmlOptions = {
-        reportHtmlName: void 0,
-        writeDataJson: false
-    };
-    let jsonOptions = {};
-    const briefOptions = output?.options || {};
-    if ('type' in briefOptions && briefOptions.type?.includes('json')) jsonOptions = briefOptions.jsonOptions || {
-        fileName: 'rsdoctor-data.json',
-        sections: {
-            moduleGraph: true,
-            chunkGraph: true,
-            rules: true
-        }
-    };
-    if ('type' in briefOptions && briefOptions.type?.includes('html') || !briefOptions.type) {
-        const outputBriefOptions = briefOptions?.htmlOptions;
-        const outputBrief = brief;
-        htmlOptions = {
-            reportHtmlName: outputBriefOptions?.reportHtmlName || outputBrief?.reportHtmlName || void 0,
-            writeDataJson: outputBriefOptions?.writeDataJson || outputBrief?.writeDataJson || false
-        };
-    }
-    return {
-        type: output.options?.type || [
-            'html'
-        ],
-        htmlOptions,
-        jsonOptions
-    };
-}
-function convertReportCodeTypeObject(reportCodeType) {
-    if (!reportCodeType) return;
-    if (reportCodeType.noCode) return 'noCode';
-    if (reportCodeType.noAssetsAndModuleSource) return 'noAssetsAndModuleSource';
-    if (reportCodeType.noModuleSource) return 'noModuleSource';
-}
-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);
-    });
-}
-export { convertReportCodeTypeObject, makeRuleSetSerializable, makeRulesSerializable, processBriefHtmlModeConfig, processModeConfigurations };

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

@@ -1,55 +0,0 @@
-import "node:module";
-import { exec } from "node:child_process";
-import { dirname, join } from "node:path";
-import { promisify } from "node:util";
-import { fileURLToPath } from "node:url";
-import { logger } from "../../logger.js";
-const execAsync = promisify(exec);
-const openBrowser_dirname = dirname(fileURLToPath(import.meta.url));
-const supportedChromiumBrowsers = [
-    'Google Chrome Canary',
-    'Google Chrome Dev',
-    'Google Chrome Beta',
-    'Google Chrome',
-    'Microsoft Edge',
-    'Brave Browser',
-    'Vivaldi',
-    'Chromium'
-];
-const getTargetBrowser = async ()=>{
-    let targetBrowser = process.env.BROWSER;
-    if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
-        const { stdout: ps } = await execAsync('ps cax');
-        targetBrowser = supportedChromiumBrowsers.find((b)=>ps.includes(b));
-    }
-    return targetBrowser;
-};
-const openWithDefaultBrowser = async (url)=>{
-    try {
-        const { default: open } = await import("open");
-        await open(url);
-        return true;
-    } catch (err) {
-        logger.error('Failed to open Rsdoctor URL.');
-        logger.error(err);
-        return false;
-    }
-};
-async function openBrowser(url, needEncodeURI = true) {
-    const shouldTryOpenChromeWithAppleScript = 'darwin' === process.platform;
-    if (shouldTryOpenChromeWithAppleScript) try {
-        const targetBrowser = await getTargetBrowser();
-        if (targetBrowser) {
-            await execAsync(`osascript openChrome.applescript "${needEncodeURI ? encodeURI(url) : url}" "${targetBrowser}"`, {
-                cwd: join(openBrowser_dirname, '../../../static')
-            });
-            return true;
-        }
-        logger.debug('Failed to find the target browser.');
-    } catch (err) {
-        logger.debug("Failed to open Rsdoctor URL with apple script.");
-        logger.debug(err);
-    }
-    return openWithDefaultBrowser(url);
-}
-export { openBrowser };

package/dist/inner-plugins/utils/plugin-common.js

@@ -1,94 +0,0 @@
-import "node:module";
-import { makeRulesSerializable } from "../index.js";
-import { SDK } from "@rsdoctor/shared/types";
-import { chalk } from "../../logger.js";
-import path from "path";
-import { openBrowser } from "./openBrowser.js";
-function safeCloneDeep(value, visited = new WeakMap()) {
-    if (null == value) return value;
-    if ('object' != typeof value) return value;
-    if (value instanceof Date) return new Date(value.getTime());
-    if (value instanceof RegExp) return new RegExp(value.source, value.flags);
-    if (visited.has(value)) return visited.get(value);
-    if (Array.isArray(value)) {
-        const len = value.length;
-        const cloned = new Array(len);
-        visited.set(value, cloned);
-        for(let i = 0; i < len; i++)cloned[i] = safeCloneDeep(value[i], visited);
-        return cloned;
-    }
-    const cloned = {};
-    visited.set(value, cloned);
-    const ownPropertyNames = Object.getOwnPropertyNames(value);
-    const ownSymbols = Object.getOwnPropertySymbols(value);
-    const enumerableKeys = Object.keys(value);
-    const enumerableKeysSet = new Set(enumerableKeys);
-    const obj = value;
-    for(let i = 0; i < enumerableKeys.length; i++){
-        const key = enumerableKeys[i];
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (!descriptor || !descriptor.get || descriptor.set) try {
-            const propValue = obj[key];
-            cloned[key] = safeCloneDeep(propValue, visited);
-        } catch  {
-            continue;
-        }
-    }
-    for(let i = 0; i < ownPropertyNames.length; i++){
-        const key = ownPropertyNames[i];
-        if (enumerableKeysSet.has(key)) continue;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (descriptor) {
-            if (!descriptor.get || descriptor.set) {
-                if (void 0 !== descriptor.set) try {
-                    const propValue = obj[key];
-                    cloned[key] = safeCloneDeep(propValue, visited);
-                } catch  {
-                    continue;
-                }
-            }
-        }
-    }
-    for(let i = 0; i < ownSymbols.length; i++){
-        const key = ownSymbols[i];
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (descriptor) {
-            if (!descriptor.get || descriptor.set) {
-                if (descriptor.enumerable || void 0 !== descriptor.set) try {
-                    const propValue = obj[key];
-                    cloned[key] = safeCloneDeep(propValue, visited);
-                } catch  {
-                    continue;
-                }
-            }
-        }
-    }
-    return cloned;
-}
-function processCompilerConfig(config) {
-    const { plugins, infrastructureLogging: _infrastructureLogging, ...rest } = config;
-    const _rest = safeCloneDeep(rest);
-    if (_rest.module?.defaultRules) makeRulesSerializable(_rest.module.defaultRules);
-    if (_rest.module?.rules) makeRulesSerializable(_rest.module.rules);
-    return {
-        ..._rest,
-        plugins: plugins.map((e)=>e?.constructor.name)
-    };
-}
-async function handleBriefModeReport(sdk, options, disableClientServer) {
-    if (!disableClientServer && options.output.mode === SDK.IMode[SDK.IMode.brief]) {
-        const outputTypes = options.output.options?.type || [];
-        const isJsonOnly = Array.isArray(outputTypes) && 1 === outputTypes.length && 'json' === outputTypes[0];
-        if (isJsonOnly) {
-            const jsonFileName = options.output.options?.jsonOptions?.fileName || 'rsdoctor-data.json';
-            const jsonFilePath = path.resolve(sdk.outputDir, jsonFileName);
-            console.log(`${chalk.green('[RSDOCTOR] generated JSON data')}: ${jsonFilePath}`);
-        } else {
-            const htmlOptions = 'htmlOptions' in options.output.options && options.output.options.htmlOptions || void 0;
-            const outputFilePath = path.resolve(sdk.outputDir, htmlOptions?.reportHtmlName || 'rsdoctor-report.html');
-            console.log(`${chalk.green('[RSDOCTOR] generated brief report')}: ${outputFilePath}`);
-            openBrowser(`file:///${outputFilePath}`);
-        }
-    }
-}
-export { handleBriefModeReport, processCompilerConfig, safeCloneDeep };