@rsdoctor/core 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/inner-plugins/constants.js

@@ -1,19 +0,0 @@
-import "node:module";
-const pluginTapName = 'RsdoctorRspackPlugin';
-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: 1000
-    });
-export { internalPluginTapPostOptions, internalPluginTapPreOptions, pluginTapName, pluginTapPostOptions, pluginTapPreOptions };

package/dist/inner-plugins/index.js

@@ -1,3 +0,0 @@
-import "node:module";
-export * from "./plugins/index.js";
-export * from "./utils/index.js";

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

@@ -1,65 +0,0 @@
-import "node:module";
-import { Utils } from "../../build-utils/build/index.js";
-import { getOriginLoaderModule, reportLoader, shouldSkipLoader } from "../utils/index.js";
-const loaderModule = function(...args) {
-    if (shouldSkipLoader(this)) return void this.callback(null, ...args);
-    this.cacheable(false);
-    const mod = getOriginLoaderModule(this);
-    if (mod.default) {
-        if (false === mod.raw && Buffer.isBuffer(args[0])) args[0] = args[0].toString();
-        let start = 0;
-        let startHRTime = [
-            0,
-            0
-        ];
-        const trap = Utils.createLoaderContextTrap.call(this, (err, res, sourceMap)=>{
-            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)) reportLoader(this, start, startHRTime, false, true, args[0].toString(), null, result);
-            }
-            return result || '';
-        } catch (error) {
-            reportLoader(this, start, startHRTime, false, true, args[0].toString(), error, null);
-            throw error;
-        }
-    }
-    this.callback(null, ...args);
-};
-const pitch = function() {
-    if (shouldSkipLoader(this)) return;
-    this.cacheable(false);
-    const mod = getOriginLoaderModule(this);
-    if (mod.pitch && 'function' == typeof mod.pitch) {
-        let start = 0;
-        let startHRTime = [
-            0,
-            0
-        ];
-        const trap = Utils.createLoaderContextTrap.call(this, (err, res)=>{
-            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)) reportLoader(this, start, startHRTime, true, true, '', null, res);
-            }
-            return res;
-        } catch (error) {
-            reportLoader(this, start, startHRTime, true, true, 'Loader Pitch Sync Error', error, null);
-            throw error;
-        }
-    }
-};
-loaderModule.raw = true;
-loaderModule.pitch = pitch;
-const raw = true;
-const proxy = loaderModule;
-export default proxy;
-export { pitch, raw };

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

@@ -1,20 +0,0 @@
-import "node:module";
-import { internalPluginTapPostOptions, internalPluginTapPreOptions } from "../constants.js";
-class InternalBasePlugin {
-    get options() {
-        return this.scheduler.options;
-    }
-    get sdk() {
-        return this.scheduler.sdk;
-    }
-    get tapPostOptions() {
-        return internalPluginTapPostOptions(this.name);
-    }
-    get tapPreOptions() {
-        return internalPluginTapPreOptions(this.name);
-    }
-    constructor(scheduler){
-        this.scheduler = scheduler;
-    }
-}
-export { InternalBasePlugin };

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

@@ -1,63 +0,0 @@
-import "node:module";
-import { Manifest } from "@rsdoctor/shared/types";
-import { InternalBasePlugin } from "./base.js";
-import { Chunks } from "../../graph/index.js";
-import { logger, time, timeEnd } from "../../logger.js";
-class InternalBundlePlugin extends InternalBasePlugin {
-    apply(compiler) {
-        time('InternalBundlePlugin.apply');
-        try {
-            this.scheduler.ensureModulesChunksGraphApplied(compiler);
-            this.changeDevtoolModuleFilename(compiler);
-            compiler.hooks.compilation.tap(this.tapPostOptions, this.thisCompilation);
-            compiler.hooks.done.tapPromise(this.tapPreOptions, this.done.bind(this));
-        } finally{
-            timeEnd('InternalBundlePlugin.apply');
-        }
-    }
-    changeDevtoolModuleFilename(compiler) {
-        const devtool = compiler.options.devtool;
-        if (devtool) {
-            if (!compiler.options.output) compiler.options.output = {};
-            compiler.options.output.devtoolModuleFilenameTemplate = '[absolute-resource-path]';
-            logger.warn("output.devtoolModuleFilenameTemplate has been changed to [absolute-resource-path], this is for bundle analysis.");
-            if ('string' == typeof devtool && devtool.includes('source-map')) compiler.options.output.devtoolFallbackModuleFilenameTemplate = ()=>'[absolute-resource-path]';
-        }
-    }
-    ensureAssetContent(name) {
-        const asset = this.map.get(name);
-        if (asset) return asset;
-        const v = {
-            content: ''
-        };
-        this.map.set(name, v);
-        return v;
-    }
-    constructor(...args){
-        super(...args), this.name = 'bundle', this.map = new Map(), this.thisCompilation = (compilation)=>{
-            time('InternalBundlePlugin.thisCompilation');
-            try {
-                if (compilation.hooks.processAssets) compilation.hooks.afterProcessAssets.tap(this.tapPostOptions, (assets)=>{
-                    Object.keys(assets).forEach((file)=>{
-                        const v = this.ensureAssetContent(file);
-                        v.content = assets[file].source().toString();
-                    });
-                });
-            } finally{
-                timeEnd('InternalBundlePlugin.thisCompilation');
-            }
-        }, this.done = async ()=>{
-            time('InternalBundlePlugin.done');
-            try {
-                if (this.scheduler.chunkGraph) Chunks.assetsContents(this.map, this.scheduler.chunkGraph, this.scheduler.options?.supports);
-                this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.ModuleGraph,
-                    Manifest.RsdoctorManifestClientRoutes.BundleSize
-                ]);
-            } finally{
-                timeEnd('InternalBundlePlugin.done');
-            }
-        };
-    }
-}
-export { InternalBundlePlugin };

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

@@ -1,74 +0,0 @@
-import "node:module";
-import { chalk, logger } from "../../logger.js";
-import { Chunks } from "../../build-utils/build/index.js";
-import { internalPluginTapPreOptions, pluginTapPostOptions } from "../constants.js";
-import { applyRspackNativePlugin, getRspackNativePlugin } from "./rspack.js";
-import { handleAfterEmitAssets } from "./sourcemapTool.js";
-let hasConsole = false;
-const ensureModulesChunksGraphFn = (compiler, _this)=>{
-    if (_this._modulesGraphApplied) return;
-    const RsdoctorRspackPlugin = getRspackNativePlugin(compiler);
-    _this._modulesGraphApplied = true;
-    const nativeGraphState = applyRspackNativePlugin(compiler, _this, RsdoctorRspackPlugin);
-    if (!_this._realSourcePathCache) _this._realSourcePathCache = new Map();
-    compiler.hooks.done.tapPromise(internalPluginTapPreOptions('moduleGraph'), async ()=>{
-        await doneHandler(_this, compiler, nativeGraphState);
-    });
-    compiler.hooks.compilation.tap({
-        ...pluginTapPostOptions,
-        name: 'RsdoctorSourceMapCollector'
-    }, (compilation)=>{
-        if (compilation.hooks.processAssets) compilation.hooks.processAssets.tapPromise({
-            name: 'RsdoctorSourceMapCollector',
-            stage: 2400
-        }, async ()=>{
-            if (!ensureDevtools(compiler)) return;
-            const { namespace, sourceMapFilenameRegex } = calculateNamespaceAndRegex(compiler);
-            await handleAfterEmitAssets(compilation, _this, sourceMapFilenameRegex, namespace);
-        });
-    });
-};
-async function doneHandler(_this, compiler, nativeGraphState) {
-    if (!nativeGraphState.chunkGraph || !_this.chunkGraph) throw new Error('[RsdoctorRspackPlugin] The Rspack native plugin did not provide chunk graph data.');
-    if (!nativeGraphState.moduleGraph) throw new Error('[RsdoctorRspackPlugin] The Rspack native plugin did not provide module graph data.');
-    const shouldParseBundle = false !== _this.options.supports.parseBundle;
-    await getModulesInfos(compiler, _this.modulesGraph, _this.chunkGraph, shouldParseBundle, _this.sourceMapSets, _this.assetsWithoutSourceMap);
-    logger.debug('reportModuleGraph start');
-    await _this.sdk.reportModuleGraph(_this.modulesGraph);
-    logger.debug('reportModuleGraph done');
-    logger.debug('reportChunkGraph start');
-    await _this.sdk.reportChunkGraph(_this.chunkGraph);
-    logger.debug('reportChunkGraph done');
-    if (_this.options.supports.generateTileGraph) logger.warn(chalk.yellow('The option generateTileGraph is deprecated. Treemap (i.e. Tile Graph) is now supported by default.'));
-    logger.debug('doneHandler done');
-}
-const ensureDevtools = (compiler)=>{
-    const devtool = compiler.options.devtool;
-    if ('string' == typeof devtool && /eval/i.test(devtool)) {
-        if (!hasConsole) logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
-        hasConsole = true;
-        return false;
-    }
-    return true;
-};
-async function getModulesInfos(compiler, moduleGraph, chunkGraph, parseBundle, sourceMapSets, assetsWithoutSourceMap) {
-    if (!moduleGraph) return;
-    try {
-        await Chunks.getAssetsModulesData(moduleGraph, chunkGraph, compiler.outputPath, sourceMapSets, parseBundle, assetsWithoutSourceMap);
-    } catch  {}
-}
-function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function calculateNamespaceAndRegex(compiler) {
-    let namespace = compiler.options.output.devtoolNamespace || compiler.options.output.library?.name || '[^/]+/';
-    if (Array.isArray(namespace)) namespace = namespace[0];
-    else if ('object' == typeof namespace && 'name' in namespace) namespace = namespace.name;
-    const safeNamespace = escapeRegExp(namespace);
-    const sourceMapFilenameRegex = new RegExp(`(?:webpack://)?(?:${safeNamespace})?([^?]*)`);
-    return {
-        namespace: namespace,
-        sourceMapFilenameRegex
-    };
-}
-export { calculateNamespaceAndRegex, ensureDevtools, ensureModulesChunksGraphFn };

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

@@ -1,65 +0,0 @@
-import "node:module";
-import { Rule } from "@rsdoctor/shared/types";
-import { InternalBasePlugin } from "./base.js";
-import { DevToolError } from "../../error/index.js";
-import { time, timeEnd } from "../../logger.js";
-class InternalErrorReporterPlugin extends InternalBasePlugin {
-    apply(compiler) {
-        time('InternalErrorReporterPlugin.apply');
-        try {
-            compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
-        } finally{
-            timeEnd('InternalErrorReporterPlugin.apply');
-        }
-    }
-    handleBundlerError(err, category, level) {
-        return DevToolError.from(err, {
-            category,
-            code: Rule.RuleMessageCodeEnumerated.Overlay,
-            controller: {
-                noStack: false
-            },
-            detail: {
-                stack: 'stack' in err ? err.stack : err.message
-            },
-            level
-        });
-    }
-    async reportWarnings(warnings) {
-        time('InternalErrorReporterPlugin.reportWarnings');
-        try {
-            const arr = warnings.map((warning)=>this.handleBundlerError(warning, Rule.RuleMessageCategory.Compile, 'Warn'));
-            this.sdk.reportError(arr);
-        } finally{
-            timeEnd('InternalErrorReporterPlugin.reportWarnings');
-        }
-    }
-    async reportErrors(errors) {
-        time('InternalErrorReporterPlugin.reportErrors');
-        try {
-            const arr = errors.map((err)=>this.handleBundlerError(err, Rule.RuleMessageCategory.Bundle, 'Error'));
-            this.sdk.reportError(arr);
-        } finally{
-            timeEnd('InternalErrorReporterPlugin.reportErrors');
-        }
-    }
-    constructor(...args){
-        super(...args), this.name = 'error-reporter', this.done = async (stats)=>{
-            time('InternalErrorReporterPlugin.done');
-            try {
-                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);
-            } finally{
-                timeEnd('InternalErrorReporterPlugin.done');
-            }
-        };
-    }
-}
-export { InternalErrorReporterPlugin };

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

@@ -1,11 +0,0 @@
-import "node:module";
-export * from "./loader.js";
-export * from "./plugins.js";
-export * from "./errors.js";
-export * from "./progress.js";
-export * from "./summary.js";
-export * from "./base.js";
-export * from "./bundle.js";
-export * from "./ensureModulesChunkGraph.js";
-export * from "./rules.js";
-export * from "./resolver.js";

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

@@ -1,108 +0,0 @@
-import "node:module";
-import { Manifest } from "@rsdoctor/shared/types";
-import { Loader } from "../../common/index.js";
-import { isEqual, omit } from "../../collection.js";
-import { interceptLoader } from "../utils/index.js";
-import { InternalBasePlugin } from "./base.js";
-import { time, timeEnd } from "../../logger.js";
-import { fileURLToPath } from "url";
-import { safeCloneDeep } from "../utils/plugin-common.js";
-class InternalLoaderPlugin extends InternalBasePlugin {
-    apply(compiler) {
-        time('InternalLoaderPlugin.apply');
-        try {
-            compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler));
-            compiler.hooks.compilation.tap(this.tapPreOptions, (compilation)=>this.compilation(compiler, compilation));
-        } finally{
-            timeEnd('InternalLoaderPlugin.apply');
-        }
-    }
-    compilation(compiler, compilation) {
-        time('InternalLoaderPlugin.compilation');
-        try {
-            if (compiler.isChild()) return;
-            const wrapper = (callback)=>(loaderContext, module)=>{
-                    const proxyLoaders = module?.loaders || loaderContext?.loaders || [];
-                    const originLoaders = proxyLoaders.map((loader)=>{
-                        const rawOptions = loader.options;
-                        const opts = 'object' == typeof rawOptions && null !== rawOptions ? rawOptions : {};
-                        if (opts[Loader.LoaderInternalPropertyName]) return {
-                            ...loader,
-                            loader: opts[Loader.LoaderInternalPropertyName].loader,
-                            options: omit(opts, Loader.LoaderInternalPropertyName)
-                        };
-                        return loader;
-                    });
-                    const newLoaders = safeCloneDeep(originLoaders);
-                    if ('object' == typeof compiler.options.cache && 'version' in compiler.options.cache && 'string' == typeof compiler.options.cache.version && compiler.options.cache.version.indexOf('next/dist/build') > -1) callback(loaderContext, module || {});
-                    else {
-                        const proxyModule = new Proxy(module || {}, {
-                            get (target, p, receiver) {
-                                if ('loaders' === p) return newLoaders;
-                                return Reflect.get(target, p, receiver);
-                            },
-                            set (target, p, newValue, receiver) {
-                                const _newValue = safeCloneDeep(newValue);
-                                if ('loaders' === p) {
-                                    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 (!isEqual(originLoaders, newLoaders)) {
-                        const rules = this.getInterceptRules(compiler, newLoaders.map((e)=>({
-                                loader: e.loader,
-                                options: e.options ?? void 0
-                            })));
-                        module.loaders = rules.map((e, i)=>({
-                                ...newLoaders[i],
-                                loader: e.loader,
-                                options: e.options
-                            }));
-                    }
-                };
-            const interceptor = {
-                register (tap) {
-                    const originFn = tap.fn;
-                    if ('function' == typeof originFn) tap.fn = wrapper(originFn);
-                    return tap;
-                }
-            };
-            compiler.webpack.NormalModule.getCompilationHooks(compilation).loader.intercept(interceptor);
-        } finally{
-            timeEnd('InternalLoaderPlugin.compilation');
-        }
-    }
-    getInterceptRules(compiler, rules) {
-        return interceptLoader(rules, this.internalLoaderPath, {
-            cwd: compiler.context || process.cwd(),
-            host: this.sdk.server.origin,
-            skipLoaders: this.options.loaderInterceptorOptions.skipLoaders
-        }, compiler.resolverFactory.get('loader', compiler.options.resolveLoader), this.sdk.root);
-    }
-    constructor(...args){
-        super(...args), this.name = 'loader', this.internalLoaderPath = fileURLToPath(new URL('../loaders/proxy.js', import.meta.url)), this.afterPlugins = (compiler)=>{
-            time('InternalLoaderPlugin.afterPlugins');
-            try {
-                if (compiler.isChild()) return;
-                compiler.options.module.rules = this.getInterceptRules(compiler, compiler.options.module.rules);
-                this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.Loaders
-                ]);
-            } finally{
-                timeEnd('InternalLoaderPlugin.afterPlugins');
-            }
-        };
-    }
-}
-export { InternalLoaderPlugin };

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

@@ -1,40 +0,0 @@
-import "node:module";
-import { Manifest } from "@rsdoctor/shared/types";
-import { Utils } from "../../build-utils/build/index.js";
-import { interceptPluginHook } from "../utils/index.js";
-import { InternalBasePlugin } from "./base.js";
-import { time, timeEnd } from "../../logger.js";
-class InternalPluginsPlugin extends InternalBasePlugin {
-    apply(compiler) {
-        time('InternalPluginsPlugin.apply');
-        try {
-            compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler));
-            compiler.hooks.compilation.tap(this.tapPostOptions, this.compilation);
-        } finally{
-            timeEnd('InternalPluginsPlugin.apply');
-        }
-    }
-    constructor(...args){
-        super(...args), this.name = 'plugins', this.afterPlugins = (compiler)=>{
-            time('InternalPluginsPlugin.afterPlugins');
-            try {
-                if (compiler.isChild()) return;
-                Utils.interceptCompilerHooks(compiler, (name, hook)=>interceptPluginHook(this.sdk, name, hook));
-                this.sdk.addClientRoutes([
-                    Manifest.RsdoctorManifestClientRoutes.Plugins
-                ]);
-            } finally{
-                timeEnd('InternalPluginsPlugin.afterPlugins');
-            }
-        }, this.compilation = (compilation)=>{
-            time('InternalPluginsPlugin.compilation');
-            try {
-                if (compilation.compiler.isChild()) return;
-                Utils.interceptCompilationHooks(compilation, (name, hook)=>interceptPluginHook(this.sdk, name, hook));
-            } finally{
-                timeEnd('InternalPluginsPlugin.compilation');
-            }
-        };
-    }
-}
-export { InternalPluginsPlugin };

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

@@ -1,35 +0,0 @@
-import "node:module";
-import { SDK } from "@rsdoctor/shared/types";
-import { InternalBasePlugin } from "./base.js";
-import { logger } from "../../logger.js";
-class InternalProgressPlugin extends InternalBasePlugin {
-    apply(compiler) {
-        const { sdk, currentProgress } = this;
-        if (compiler.webpack && compiler.webpack.ProgressPlugin) {
-            const progress = new compiler.webpack.ProgressPlugin((percentage, msg)=>{
-                currentProgress.percentage = percentage;
-                currentProgress.message = msg || '';
-                const api = SDK.ServerAPI.APIExtends.GetCompileProgress;
-                try {
-                    sdk.server.sendAPIDataToClient(api, {
-                        req: {
-                            api,
-                            body: void 0
-                        },
-                        res: currentProgress
-                    });
-                } catch (e) {
-                    logger.debug(e);
-                }
-            });
-            progress.apply(compiler);
-        }
-    }
-    constructor(...args){
-        super(...args), this.name = 'progress', this.currentProgress = {
-            percentage: 100,
-            message: ''
-        };
-    }
-}
-export { InternalProgressPlugin };

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

@@ -1,57 +0,0 @@
-import "node:module";
-import { Manifest } from "@rsdoctor/shared/types";
-import { Time } from "../../common/index.js";
-import { InternalBasePlugin } from "./base.js";
-class InternalResolverPlugin extends InternalBasePlugin {
-    apply(compiler) {
-        this.scheduler.ensureModulesChunksGraphApplied(compiler);
-        compiler.hooks.normalModuleFactory.tap(this.tapPostOptions, this.handleNormalModuleFactory);
-        this.sdk.addClientRoutes([
-            Manifest.RsdoctorManifestClientRoutes.ModuleResolve
-        ]);
-    }
-    constructor(...args){
-        super(...args), this.name = 'resolver', this.resolveDataMap = new Map(), this.handleNormalModuleFactory = (normalModuleFactory)=>{
-            normalModuleFactory.hooks.beforeResolve.tap(this.tapPostOptions, (resolveData)=>{
-                if (!resolveData) return;
-                const issuer = resolveData.contextInfo?.issuer || resolveData.context || '';
-                const request = resolveData.request;
-                if (issuer && request) {
-                    const key = `${issuer}::${request}`;
-                    this.resolveDataMap.set(key, {
-                        startAt: Date.now(),
-                        startHRTime: process.hrtime(),
-                        request
-                    });
-                }
-            });
-            normalModuleFactory.hooks.afterResolve.tap(this.tapPostOptions, (resolveData)=>{
-                if (!resolveData) return;
-                const issuer = resolveData.contextInfo?.issuer || resolveData.context || '';
-                const request = resolveData.request;
-                const result = resolveData.createData?.resource || resolveData.resourceResolveData?.path;
-                if (issuer && request) {
-                    const key = `${issuer}::${request}`;
-                    const startData = this.resolveDataMap.get(key);
-                    if (startData) {
-                        const data = {
-                            isEntry: Boolean(issuer),
-                            issuerPath: issuer,
-                            request: startData.request,
-                            startAt: startData.startAt,
-                            endAt: Time.getCurrentTimestamp(startData.startAt, startData.startHRTime),
-                            result: result || '',
-                            pid: process.pid,
-                            ppid: process.ppid
-                        };
-                        this.sdk.reportResolver([
-                            data
-                        ]);
-                        this.resolveDataMap.delete(key);
-                    }
-                }
-            });
-        };
-    }
-}
-export { InternalResolverPlugin };

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

@@ -1,99 +0,0 @@
-import "node:module";
-import { ChunkGraph } from "../../graph/index.js";
-import { Chunks, ModuleGraph } from "../../build-utils/build/index.js";
-import { internalPluginTapPreOptions } from "../constants.js";
-import { logger } from "../../logger.js";
-function getRspackNativePlugin(compiler) {
-    const RsdoctorRspackPlugin = compiler.webpack.experiments?.RsdoctorPlugin;
-    if (!RsdoctorRspackPlugin) throw new Error('[RsdoctorRspackPlugin] The current Rspack version does not provide experiments.RsdoctorPlugin. Please upgrade Rspack.');
-    return RsdoctorRspackPlugin;
-}
-function applyRspackNativePlugin(compiler, plugin, RsdoctorRspackPlugin) {
-    const state = {
-        chunkGraph: false,
-        moduleGraph: false
-    };
-    logger.debug('[RspackNativePlugin] Apply hooks');
-    compiler.hooks.compilation.tap('RsdoctorRspackPlugin', (compilation)=>{
-        state.chunkGraph = false;
-        state.moduleGraph = false;
-        const hooks = RsdoctorRspackPlugin.getCompilationHooks(compilation);
-        const cached = {};
-        const dependOn = {
-            chunkGraphData: [],
-            moduleGraphData: [
-                'chunkGraphData'
-            ],
-            assetPatchData: [
-                'chunkGraphData'
-            ],
-            moduleIdsPatchData: [
-                'moduleGraphData'
-            ],
-            moduleSourcesPatchData: [
-                'moduleGraphData'
-            ]
-        };
-        const consumer = {
-            chunkGraphData: (data)=>{
-                plugin.chunkGraph = new ChunkGraph();
-                Chunks.patchNativeChunkGraph(plugin.chunkGraph, data);
-                state.chunkGraph = true;
-            },
-            moduleGraphData: (data)=>{
-                ModuleGraph.patchNativeModuleGraph(plugin.modulesGraph, plugin.chunkGraph, data);
-                state.moduleGraph = true;
-            },
-            moduleIdsPatchData: (data)=>{
-                ModuleGraph.patchNativeModuleIds(plugin.modulesGraph, data);
-            },
-            moduleSourcesPatchData: (data)=>{
-                ModuleGraph.patchNativeModuleSources(plugin.modulesGraph, data);
-                if (plugin.options.features.treeShaking) ModuleGraph.extractSideEffectCodes(plugin.modulesGraph);
-            },
-            assetPatchData: (data)=>{
-                Chunks.patchNativeAssets(plugin.chunkGraph, data);
-            }
-        };
-        const tryConsumeData = (key, data)=>{
-            if (true === cached[key]) return;
-            cached[key] = data;
-            while(true){
-                let hasConsumed = false;
-                for (const [_task, deps] of Object.entries(dependOn)){
-                    const task = _task;
-                    if (true === cached[task] || void 0 === cached[task]) continue;
-                    const prepared = deps.every((dep)=>true === cached[dep]);
-                    if (prepared) {
-                        consumer[task](cached[task]);
-                        cached[task] = true;
-                        hasConsumed = true;
-                    }
-                }
-                if (!hasConsumed) break;
-            }
-        };
-        hooks.chunkGraph.tap(internalPluginTapPreOptions('nativeChunkGraph'), (rawChunkGraph)=>{
-            logger.debug('[RspackNativePlugin] Called chunkGraph hook');
-            tryConsumeData('chunkGraphData', rawChunkGraph);
-        });
-        hooks.moduleGraph.tap(internalPluginTapPreOptions('nativeModuleGraph'), (rawModuleGraph)=>{
-            logger.debug('[RspackNativePlugin] Called moduleGraph hook');
-            tryConsumeData('moduleGraphData', rawModuleGraph);
-        });
-        hooks.moduleIds.tap(internalPluginTapPreOptions('nativeSourcePatch'), (rawModuleIdsPatch)=>{
-            logger.debug('[RspackNativePlugin] Called moduleIds hook');
-            tryConsumeData('moduleIdsPatchData', rawModuleIdsPatch);
-        });
-        hooks.moduleSources.tap(internalPluginTapPreOptions('nativeModuleSourcesPatch'), (rawModuleSourcesPatch)=>{
-            logger.debug('[RspackNativePlugin] Called moduleSources hook');
-            tryConsumeData('moduleSourcesPatchData', rawModuleSourcesPatch);
-        });
-        hooks.assets.tap(internalPluginTapPreOptions('nativeAssetPatch'), (rawAssetPatch)=>{
-            logger.debug('[RspackNativePlugin] Called assets hook');
-            tryConsumeData('assetPatchData', rawAssetPatch);
-        });
-    });
-    return state;
-}
-export { applyRspackNativePlugin, getRspackNativePlugin };