@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/sdk/sdk/core.js

@@ -0,0 +1,163 @@
+import "node:module";
+import { Constants, Manifest } from "@rsdoctor/shared/types";
+import { EnvInfo, File, Json } from "../../build-utils/index.js";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import node_process from "node:process";
+import { AsyncSeriesHook } from "tapable";
+import { Algorithm, decycle } from "../../common/index.js";
+import { logger } from "../../logger.js";
+import { transformDataUrls } from "../utils/index.js";
+class SDKCore {
+    get outputDir() {
+        return this._outputDir;
+    }
+    get name() {
+        return this._name;
+    }
+    async bootstrap() {
+        const [cpu, memory, nodeVersion, yarnVersion, npmVersion, pnpmVersion] = await Promise.all([
+            EnvInfo.getCPUInfo(),
+            EnvInfo.getMemoryInfo(),
+            EnvInfo.getNodeVersion(),
+            EnvInfo.getYarnVersion(),
+            EnvInfo.getNpmVersion(),
+            EnvInfo.getPnpmVersion()
+        ]);
+        this._envinfo = {
+            ...this._envinfo,
+            cpu,
+            memory,
+            nodeVersion,
+            yarnVersion,
+            npmVersion,
+            pnpmVersion
+        };
+        const hash = createHash('md5').update([
+            this.name,
+            this.root,
+            JSON.stringify(this._envinfo),
+            Date.now()
+        ].join('_')).digest('hex');
+        this.setHash(hash);
+    }
+    async dispose() {}
+    setOutputDir(outputDir) {
+        this._outputDir = outputDir;
+    }
+    setName(name) {
+        this._name = name;
+    }
+    setHash(hash) {
+        this.hash = hash;
+    }
+    getHash() {
+        return this.hash;
+    }
+    getClientRoutes() {
+        return [
+            ...this._clientRoutes
+        ];
+    }
+    addClientRoutes(routes) {
+        routes.forEach((route)=>{
+            this._clientRoutes.add(route);
+        });
+        this.onDataReport();
+    }
+    async writePieces(storeData, _options) {
+        const { outputDir } = this;
+        const manifest = node_path.resolve(outputDir, Constants.RsdoctorOutputManifest);
+        this.diskManifestPath = manifest;
+        await File.fse.ensureDir(outputDir);
+        const urlsPromiseList = [];
+        for (const key of Object.keys(storeData)){
+            const data = storeData[key];
+            if ('object' != typeof data) {
+                urlsPromiseList.push({
+                    name: key,
+                    files: data
+                });
+                continue;
+            }
+            const jsonStr = await (async ()=>{
+                try {
+                    if ('configs' === key) return JSON.stringify(decycle(data));
+                    return JSON.stringify(data);
+                } catch  {
+                    return Json.stringify(data);
+                }
+            })();
+            if (Array.isArray(jsonStr)) {
+                let fileOffset = 0;
+                for (const str of jsonStr){
+                    const result = await this.writeToFolder(str, outputDir, key, fileOffset);
+                    fileOffset += result.files.length;
+                    urlsPromiseList.push(result);
+                }
+            } else urlsPromiseList.push(this.writeToFolder(jsonStr, outputDir, key));
+        }
+        const dataUrls = await Promise.all(urlsPromiseList);
+        logger.debug(`SDKCore.writePieces extraConfig: ${JSON.stringify(this.extraConfig)}`, '[SDKCore.writePieces]');
+        this.cloudData = {
+            client: {
+                enableRoutes: this.getClientRoutes()
+            },
+            data: transformDataUrls(dataUrls)
+        };
+    }
+    async writeManifest() {
+        const { cloudData: data, diskManifestPath } = this;
+        const dataStr = JSON.stringify(data, null, 2);
+        logger.debug(`SDKCore.writeManifest extraConfig: ${this.extraConfig}`, '[SDKCore.writeManifest]');
+        const dir = node_path.dirname(diskManifestPath);
+        const base = node_path.basename(diskManifestPath);
+        const tmpPath = node_path.join(dir, `${base}.${Date.now()}.${randomUUID()}.tmp`);
+        await File.fse.outputFile(tmpPath, dataStr);
+        node_fs.renameSync(tmpPath, diskManifestPath);
+        return diskManifestPath;
+    }
+    async saveManifest(data, options) {
+        await this.writePieces(data, options);
+        const manifestDiskPath = await this.writeManifest();
+        await this.hooks.afterSaveManifest.promise({
+            manifestWithShardingFiles: this.cloudData,
+            manifestDiskPath
+        });
+        return manifestDiskPath;
+    }
+    writeToFolder(jsonStr, dir, key, index) {
+        const sharding = new File.FileSharding(Algorithm.compressText(jsonStr));
+        const folder = node_path.resolve(dir, key);
+        const writer = sharding.writeStringToFolder(folder, '', index);
+        return writer.then((item)=>{
+            const res = {
+                name: key,
+                files: item.map((el)=>({
+                        path: node_path.resolve(folder, el.filename),
+                        basename: el.filename,
+                        content: el.content
+                    }))
+            };
+            return res;
+        });
+    }
+    constructor({ name, root }){
+        this.hooks = {
+            afterSaveManifest: new AsyncSeriesHook([
+                'result'
+            ])
+        };
+        this._envinfo = {};
+        this._clientRoutes = new Set([
+            Manifest.RsdoctorManifestClientRoutes.Overall
+        ]);
+        this.diskManifestPath = '';
+        this._name = name;
+        this.root = root;
+        this.pid = node_process.pid;
+        this._outputDir = node_path.join(this.outputDir || this.root, Constants.RsdoctorOutputFolder);
+    }
+}
+export { SDKCore };

package/dist/sdk/sdk/index.d.ts

@@ -0,0 +1,52 @@
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+import { RawSourceMap, SourceMapConsumer } from 'source-map';
+import { RsdoctorServer } from '../server/index.js';
+import { RsdoctorRspackSDKOptions } from './types.js';
+import { SDKCore } from './core.js';
+export * from '../utils/openBrowser.js';
+export * from '../utils/base.js';
+export { resolveClientDiffHtmlPath } from '../server/client.js';
+export declare class RsdoctorSDK<T extends RsdoctorRspackSDKOptions = RsdoctorRspackSDKOptions> extends SDKCore<T> implements SDK.RsdoctorBuilderSDKInstance {
+    server: RsdoctorServer;
+    extraConfig: SDK.SDKOptionsType | undefined;
+    type: SDK.ToDataType;
+    root: string;
+    private _summary;
+    private _configs;
+    private _errors;
+    private _loader;
+    private _loaderStart;
+    private _resolver;
+    private _plugin;
+    private _moduleGraph;
+    private _chunkGraph;
+    private _rawSourceMapCache;
+    private _sourceMap;
+    private _packageGraph;
+    constructor(options: T);
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    applyErrorFix(id: number): Promise<void>;
+    clear(): void;
+    clearSourceMapCache(): void;
+    getSourceMap(file: string): Promise<SourceMapConsumer | undefined>;
+    reportSourceMap(data: RawSourceMap): void;
+    reportConfiguration(config: SDK.ConfigData[0]): void;
+    reportError(errors: Error[]): void;
+    reportLoader(data: SDK.LoaderData): void;
+    reportLoaderStartOrEnd(data: SDK.ResourceLoaderData): void;
+    reportResolver(data: SDK.ResolverData): void;
+    reportPlugin(data: SDK.PluginData): void;
+    reportModuleGraph(data: SDK.ModuleGraphInstance): void;
+    reportPackageGraph(data: SDK.PackageGraphInstance): void;
+    reportChunkGraph(data: SDK.ChunkGraphInstance): void;
+    reportSummaryData(part: Partial<SDK.SummaryData>): void;
+    createPackageGraph(): void;
+    writeStore(options?: SDK.WriteStoreOptionsType): Promise<string>;
+    getStoreData(): SDK.BuilderStoreData;
+    getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
+    getRuleContext(_options: SDK.RuntimeContextOptions): SDK.RuntimeContext;
+    onDataReport(): void | Promise<void>;
+    addRsdoctorDataToHTML(storeData: SDK.BuilderStoreData, htmlContent: string): string;
+    inlineScriptsAndStyles(htmlFilePath: string): string;
+}

package/dist/sdk/sdk/index.js

@@ -0,0 +1,435 @@
+import "node:module";
+import node_fs from "node:fs";
+import fs_extra from "fs-extra";
+import path_0 from "path";
+import { createRequire } from "module";
+import { DevToolError } from "../../error/index.js";
+import { Constants, SDK } from "@rsdoctor/shared/types";
+import { SourceMapConsumer } from "source-map";
+import { ChunkGraph, ModuleGraph, PackageGraph } from "../../graph/index.js";
+import { logger } from "../../logger.js";
+import { RsdoctorServer } from "../server/index.js";
+import { RsdoctorFakeServer } from "../server/fakeServer.js";
+import { SDKCore } from "./core.js";
+import { Algorithm, Lodash, decycle } from "../../common/index.js";
+import { findRoot } from "../utils/index.js";
+export * from "../utils/openBrowser.js";
+export * from "../utils/base.js";
+const sdk_require = createRequire(import.meta.url);
+class RsdoctorSDK extends SDKCore {
+    async bootstrap() {
+        logger.debug(`${Date.now()}`, '[RsdoctorSDK][bootstrap start]');
+        if (this.server) await this.server.bootstrap();
+        await super.bootstrap();
+        logger.debug(`${Date.now()} ${this.server.origin}`, '[RsdoctorSDK][bootstrap end]');
+    }
+    async dispose() {
+        logger.debug(`${Date.now()}`, '[RsdoctorSDK][dispose start]');
+        if (this.server) await this.server.dispose();
+        await super.dispose();
+        logger.debug(`${Date.now()}`, '[RsdoctorSDK][dispose end]');
+    }
+    async applyErrorFix(id) {
+        const { _errors: errors } = this;
+        const error = errors.find((err)=>err.id === id);
+        if (!error || !error.path || !error.fixData || error.fixData.isFixed) return;
+        const { path: filePath, fixData } = error;
+        const sameFileErrors = errors.filter((item)=>item.path === filePath && item !== error);
+        let content = (await node_fs.promises.readFile(filePath, 'utf-8')).toString();
+        const startTxt = content.substring(0, fixData.start);
+        const endTxt = content.substring(fixData.end, content.length);
+        const offset = (fixData.newText ?? '').length - (fixData.end - fixData.start);
+        content = startTxt + fixData.newText + endTxt;
+        for (const other of sameFileErrors){
+            const { fixData: otherFixData } = other;
+            if (otherFixData) {
+                if (otherFixData.start >= fixData.end) {
+                    otherFixData.start += offset;
+                    otherFixData.end += offset;
+                }
+            }
+        }
+        await node_fs.promises.writeFile(filePath, content);
+    }
+    clear() {
+        this._errors = [];
+        this._loader = [];
+        this._resolver = [];
+        this._plugin = {};
+        this._moduleGraph = new ModuleGraph();
+        this._chunkGraph = new ChunkGraph();
+    }
+    clearSourceMapCache() {
+        this._rawSourceMapCache = new Map();
+        this._sourceMap = new Map();
+    }
+    async getSourceMap(file) {
+        const { _sourceMap: sourceMap, _rawSourceMapCache: rawMap } = this;
+        if (sourceMap.has(file)) return sourceMap.get(file);
+        const rawData = rawMap.get(file);
+        if (!rawData || rawData.version < 0 || !rawData.sourcesContent?.[0] || !rawData.mappings) return Promise.resolve(void 0);
+        try {
+            const result = await new SourceMapConsumer(rawData);
+            sourceMap.set(file, result);
+            return result;
+        } catch  {
+            return Promise.resolve(void 0);
+        }
+    }
+    reportSourceMap(data) {
+        this._rawSourceMapCache.set(data.file, data);
+    }
+    reportConfiguration(config) {
+        config.root ??= this.root;
+        this._configs.push(config);
+        this.onDataReport();
+    }
+    reportError(errors) {
+        errors.forEach((item)=>{
+            this._errors.push(DevToolError.from(item, {
+                code: this.name
+            }));
+        });
+        this.onDataReport();
+    }
+    reportLoader(data) {
+        data.forEach((item)=>{
+            if (this.extraConfig?.mode === SDK.IMode[SDK.IMode.brief]) item.loaders.forEach((_loader)=>{
+                _loader.input = void 0;
+                _loader.result = void 0;
+            });
+            let match = this._loader.find((e)=>e.resource.path === item.resource.path);
+            if (match) match.loaders.push(...item.loaders);
+            else {
+                match = item;
+                this._loader.push(item);
+            }
+            match.loaders.sort((a, b)=>{
+                if (a.startAt !== b.startAt) return a.startAt - b.startAt;
+                if (a.isPitch) {
+                    if (b.isPitch) return a.loaderIndex - b.loaderIndex;
+                    return -1;
+                }
+                if (b.isPitch) return 1;
+                return b.loaderIndex - a.loaderIndex;
+            });
+        });
+        this.onDataReport();
+    }
+    reportLoaderStartOrEnd(data) {
+        const _builtinLoader = data.loaders[0];
+        if (_builtinLoader.startAt) this._loaderStart.push(data);
+        else if (_builtinLoader.endAt) {
+            const matchLoaderStart = this._loaderStart.find((e)=>e.resource.path === data.resource.path && e.loaders[0].loader === _builtinLoader.loader);
+            if (matchLoaderStart) {
+                matchLoaderStart.loaders[0].result = _builtinLoader.result;
+                matchLoaderStart.loaders[0].endAt = _builtinLoader.endAt;
+                this.reportLoader([
+                    matchLoaderStart
+                ]);
+            }
+        }
+    }
+    reportResolver(data) {
+        data.forEach((item)=>this._resolver.push(item));
+        this.onDataReport();
+    }
+    reportPlugin(data) {
+        Object.keys(data).forEach((hook)=>{
+            if (this._plugin[hook]) data[hook].forEach((item)=>{
+                this._plugin[hook].push(item || void 0);
+            });
+            else this._plugin[hook] = data[hook];
+        });
+        this.onDataReport();
+    }
+    reportModuleGraph(data) {
+        logger.debug(`data size: ${data.size()}`, '[SDK.reportModuleGraph][start]');
+        this._moduleGraph.fromInstance(data);
+        this.createPackageGraph();
+        this.onDataReport();
+        logger.debug(`sdk._moduleGraph size: ${this._moduleGraph.size()}`, '[SDK reportModuleGraph][end]');
+    }
+    reportPackageGraph(data) {
+        logger.debug('[SDK.reportPackageGraph][start]');
+        if (!this._packageGraph) this._packageGraph = data;
+        this.onDataReport();
+        logger.debug(`sdk._packageGraph size: ${this._packageGraph.getPackages().length}`, '[SDK reportPackageGraph][end]');
+    }
+    reportChunkGraph(data) {
+        this._chunkGraph.addAsset(...data.getAssets());
+        this._chunkGraph.addChunk(...data.getChunks());
+        this._chunkGraph.addEntryPoint(...data.getEntryPoints());
+        this.onDataReport();
+    }
+    reportSummaryData(part) {
+        const keys = [
+            'costs'
+        ];
+        for (const key of keys){
+            const v = part[key];
+            if (v) if ('object' == typeof v) if (Array.isArray(v)) this._summary[key] = [
+                ...this._summary[key] || [],
+                ...v
+            ];
+            else this._summary[key] = {
+                ...this._summary[key] || {},
+                ...v
+            };
+            else this._summary[key] = v;
+        }
+        this.onDataReport();
+    }
+    createPackageGraph() {
+        logger.debug(`sdk._moduleGraph size: ${this._moduleGraph.size()}`, '[SDK.createPackageGraph][start]');
+        if (!this._packageGraph) {
+            const pkgGraph = PackageGraph.fromModuleGraph(this._moduleGraph, this.root, (path)=>{
+                try {
+                    const exists = node_fs.existsSync(path);
+                    if (exists) {
+                        const res = fs_extra.readJsonSync(path);
+                        return res;
+                    }
+                } catch (error) {
+                    const { message, stack } = error;
+                    logger.debug(()=>`sdk.createPackageGraph error, path: ${path}, error message: ${stack || message}`, '[SDK.createPackageGraph][error]');
+                }
+            });
+            this._packageGraph = pkgGraph;
+            logger.debug(`sdk._packageGraph packages: ${this._packageGraph.getPackages().length}`, '[SDK.createPackageGraph][end]');
+        }
+    }
+    async writeStore(options) {
+        logger.debug("sdk.writeStore has run.", '[SDK.writeStore][end]');
+        let htmlPath = '';
+        if (this.extraConfig?.mode === SDK.IMode[SDK.IMode.brief]) {
+            const clientHtmlPath = this.extraConfig.innerClientPath ? this.extraConfig.innerClientPath : sdk_require.resolve('@rsdoctor/client');
+            if (this.extraConfig?.brief?.type?.includes('json')) {
+                const data = this.getStoreData();
+                const clientRoutes = this.getClientRoutes();
+                const jsonData = {
+                    data,
+                    clientRoutes
+                };
+                node_fs.mkdirSync(this.outputDir, {
+                    recursive: true
+                });
+                node_fs.writeFileSync(path_0.resolve(this.outputDir, this.extraConfig.brief.jsonOptions?.fileName ?? 'rsdoctor-data.json'), JSON.stringify(jsonData));
+            }
+            if (this.extraConfig.brief?.type?.includes('html')) htmlPath = this.inlineScriptsAndStyles(clientHtmlPath);
+            return htmlPath;
+        }
+        return this.saveManifest(this.getStoreData(), options || {});
+    }
+    getStoreData() {
+        const ctx = this;
+        const briefOptions = this.extraConfig?.brief;
+        const sections = briefOptions?.jsonOptions?.sections;
+        const isJsonType = briefOptions?.type?.includes('json');
+        return {
+            get hash () {
+                return ctx.hash;
+            },
+            get root () {
+                return ctx.root;
+            },
+            get envinfo () {
+                return ctx._envinfo;
+            },
+            get pid () {
+                return ctx.pid;
+            },
+            get errors () {
+                if (isJsonType && sections && !sections.rules) return [];
+                return ctx._errors.map((err)=>err.toData());
+            },
+            get configs () {
+                return ctx._configs.slice();
+            },
+            get summary () {
+                return {
+                    ...ctx._summary
+                };
+            },
+            get resolver () {
+                return ctx._resolver.slice();
+            },
+            get loader () {
+                return ctx._loader.slice();
+            },
+            get moduleGraph () {
+                if (isJsonType && sections && !sections.moduleGraph) return {
+                    dependencies: [],
+                    modules: [],
+                    moduleGraphModules: [],
+                    exports: [],
+                    sideEffects: [],
+                    variables: [],
+                    layers: []
+                };
+                return ctx._moduleGraph.toData({
+                    contextPath: ctx._configs?.[0]?.config?.context || '',
+                    briefOptions
+                });
+            },
+            get chunkGraph () {
+                if (isJsonType && sections && !sections.chunkGraph) return {
+                    assets: [],
+                    chunks: [],
+                    entrypoints: []
+                };
+                return ctx._chunkGraph.toData(ctx.type);
+            },
+            get moduleCodeMap () {
+                if (ctx.extraConfig?.mode === SDK.IMode[SDK.IMode.brief]) return {};
+                return ctx._moduleGraph.toCodeData(ctx.type);
+            },
+            get plugin () {
+                return {
+                    ...ctx._plugin
+                };
+            },
+            get packageGraph () {
+                return ctx._packageGraph ? ctx._packageGraph.toData() : {
+                    packages: [],
+                    dependencies: []
+                };
+            },
+            get treeShaking () {
+                if (ctx.extraConfig?.mode === SDK.IMode[SDK.IMode.brief]) return;
+                if (!ctx.extraConfig?.features?.treeShaking) return;
+                return ctx._moduleGraph.toTreeShakingData();
+            },
+            get otherReports () {
+                return {
+                    treemapReportHtml: ''
+                };
+            }
+        };
+    }
+    getManifestData() {
+        const dataValue = this.getStoreData();
+        const data = {
+            client: {
+                enableRoutes: this.getClientRoutes()
+            },
+            data: Object.keys(dataValue).reduce((t, e)=>{
+                const _e = e;
+                if (dataValue[_e] && 'object' == typeof dataValue[_e]) t[e] = [
+                    `${this.server.origin}${SDK.ServerAPI.API.LoadDataByKey}/${e}`
+                ];
+                else t[e] = dataValue[_e];
+                return t;
+            }, {}),
+            __LOCAL__SERVER__: true,
+            __SOCKET__PORT__: this.server.socketUrl.port.toString(),
+            __SOCKET__URL__: this.server.socketUrl.socketUrl
+        };
+        return data;
+    }
+    getRuleContext(_options) {
+        this.createPackageGraph();
+        return {
+            root: this.root,
+            errors: this._errors.slice(),
+            configs: this._configs.slice(),
+            moduleGraph: this._moduleGraph,
+            chunkGraph: this._chunkGraph,
+            packageGraph: this._packageGraph,
+            loader: this._loader.slice(),
+            otherReports: {
+                treemapReportHtml: ''
+            }
+        };
+    }
+    onDataReport() {
+        this.server.broadcast();
+    }
+    addRsdoctorDataToHTML(storeData, htmlContent) {
+        let compressTextScripts = `<script>window.${Constants.WINDOW_RSDOCTOR_TAG}={}</script>`;
+        for (const key of Object.keys(storeData)){
+            const data = storeData[key];
+            const jsonStrFn = ()=>{
+                try {
+                    if ('configs' === key) return JSON.stringify(decycle(data));
+                    return JSON.stringify(data);
+                } catch (error) {
+                    console.error(error);
+                    return '';
+                }
+            };
+            const compressText = Algorithm.compressText(jsonStrFn());
+            compressTextScripts = `${compressTextScripts} <script>window.${Constants.WINDOW_RSDOCTOR_TAG}.${key}=${JSON.stringify(compressText)}</script>`;
+        }
+        compressTextScripts = `${compressTextScripts} <script>window.${Constants.WINDOW_RSDOCTOR_TAG}.enableRoutes=${JSON.stringify(this.getClientRoutes())}</script>`;
+        htmlContent = htmlContent.replace('<body>', `<body>${compressTextScripts}`);
+        return htmlContent;
+    }
+    inlineScriptsAndStyles(htmlFilePath) {
+        function inlineScripts(basePath, scripts) {
+            return scripts.map((src)=>{
+                const scriptPath = resolveFilePath(basePath, src);
+                try {
+                    const scriptContent = node_fs.readFileSync(scriptPath, 'utf-8');
+                    return `<script>${scriptContent}</script>`;
+                } catch (error) {
+                    console.error(`Could not read script at ${scriptPath}:`, error);
+                    return '';
+                }
+            }).join('');
+        }
+        function resolveFilePath(basePath, filePath) {
+            if (filePath.startsWith('/')) return path_0.resolve(basePath, filePath.slice(1));
+            return path_0.resolve(basePath, filePath);
+        }
+        function inlineCss(basePath, cssFiles) {
+            return cssFiles.map((href)=>{
+                const cssPath = resolveFilePath(basePath, href);
+                try {
+                    const cssContent = node_fs.readFileSync(cssPath, 'utf-8');
+                    return `<style>${cssContent}</style>`;
+                } catch (error) {
+                    console.error(`Could not read CSS at ${cssPath}:`, error);
+                    return '';
+                }
+            }).join('');
+        }
+        let htmlContent = node_fs.readFileSync(htmlFilePath, 'utf-8');
+        const basePath = path_0.dirname(htmlFilePath);
+        const scriptSrcs = Array.from(htmlContent.matchAll(/<script\s+(?:defer="defer"|defer)\s+src=["'](.+?)["']><\/script>/g), (m)=>m[1]);
+        const cssHrefs = Array.from(htmlContent.matchAll(/<link\s+href=["'](.+?)["']\s+rel="stylesheet">/g), (m)=>m[1]);
+        htmlContent = htmlContent.replace(/<script\s+.*?src=["'].*?["']><\/script>/g, '');
+        htmlContent = htmlContent.replace(/<link\s+.*?rel=["']stylesheet["'].*?>/g, '');
+        const inlinedScripts = inlineScripts(basePath, scriptSrcs);
+        const inlinedCss = inlineCss(basePath, cssHrefs);
+        const index = htmlContent.indexOf('</body>');
+        htmlContent = htmlContent.slice(0, index) + inlinedCss + inlinedScripts + htmlContent.slice(index);
+        htmlContent = this.addRsdoctorDataToHTML(this.getStoreData(), htmlContent);
+        const outputFilePath = path_0.resolve(this.outputDir, this.extraConfig?.brief?.htmlOptions?.reportHtmlName || 'rsdoctor-report.html');
+        node_fs.mkdirSync(path_0.dirname(outputFilePath), {
+            recursive: true
+        });
+        node_fs.writeFileSync(outputFilePath, htmlContent, {
+            encoding: 'utf-8',
+            flag: 'w'
+        });
+        return outputFilePath;
+    }
+    constructor(options){
+        super(options), this._summary = {
+            costs: []
+        }, this._configs = [], this._errors = [], this._loader = [], this._loaderStart = [], this._resolver = [], this._plugin = {}, this._moduleGraph = new ModuleGraph(), this._chunkGraph = new ChunkGraph(), this._rawSourceMapCache = new Map(), this._sourceMap = new Map();
+        const serverConfig = options.config?.server;
+        const port = serverConfig?.port ?? options.port;
+        this.server = options.config?.noServer ? new RsdoctorFakeServer(this, port) : new RsdoctorServer(this, port, {
+            innerClientPath: options.config?.innerClientPath || '',
+            printServerUrl: options.config?.printLog?.serverUrls,
+            cors: serverConfig?.cors
+        });
+        this.type = Lodash.isNumber(options.type) ? options.type : SDK.ToDataType.Normal;
+        this.extraConfig = options.config;
+        this.root = findRoot() ?? '';
+    }
+}
+export { resolveClientDiffHtmlPath } from "../server/client.js";
+export { RsdoctorSDK };

package/dist/sdk/sdk/types.d.ts

@@ -0,0 +1,26 @@
+import { SDK } from '@rsdoctor/shared/types';
+export interface DataWithUrl {
+    name: string;
+    files: {
+        path: string;
+        basename: string;
+        content: Buffer;
+    }[] | string;
+}
+export interface RsdoctorSDKOptions {
+    name: string;
+    root: string;
+}
+/**
+ * sdk options for builder.
+ */
+export interface RsdoctorBuilderSDK extends RsdoctorSDKOptions {
+    type?: SDK.ToDataType;
+    /**
+     * port for client server
+     */
+    port?: number;
+    config?: SDK.SDKOptionsType;
+}
+export type RsdoctorRspackSDKOptions = RsdoctorBuilderSDK;
+export type RsdoctorEMOSDKOptions = RsdoctorSDKOptions;

package/dist/sdk/sdk/types.js

@@ -0,0 +1 @@
+import "node:module";

package/dist/sdk/server/apis/alerts.d.ts

@@ -0,0 +1,5 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class AlertsAPI extends BaseAPI {
+    getPackageRelationAlertDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPackageRelationAlertDetails>>;
+}