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

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>>;
+}

package/dist/sdk/server/apis/alerts.js

@@ -0,0 +1,30 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class AlertsAPI extends BaseAPI {
+    async getPackageRelationAlertDetails() {
+        const { req } = this.ctx;
+        const { id, target } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPackageRelationAlertDetails, {
+            id,
+            target
+        });
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetPackageRelationAlertDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], AlertsAPI.prototype, "getPackageRelationAlertDetails", null);
+export { AlertsAPI };

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

@@ -0,0 +1,11 @@
+import { Data } from '../../../common/index.js';
+import { Manifest, SDK } from '@rsdoctor/shared/types';
+export declare class BaseAPI implements Manifest.ManifestDataLoader {
+    [key: string | symbol]: any;
+    readonly ctx: SDK.ServerAPI.APIContext;
+    protected dataLoader: Data.APIDataLoader;
+    constructor(sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance);
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadData(key: string): Promise<void>;
+}

package/dist/sdk/server/apis/base.js

@@ -0,0 +1,22 @@
+import "node:module";
+import { Data } from "../../../common/index.js";
+class BaseAPI {
+    async loadManifest() {
+        return this.ctx.sdk.getManifestData();
+    }
+    async loadData(key) {
+        const data = this.ctx.sdk.getStoreData();
+        const sep = '.';
+        let res = data[key];
+        if (key.includes(sep)) res = key.split(sep).reduce((t, k)=>t[k], data);
+        return res;
+    }
+    constructor(sdk, server){
+        this.ctx = {
+            sdk,
+            server
+        };
+        this.dataLoader = new Data.APIDataLoader(this);
+    }
+}
+export { BaseAPI };

package/dist/sdk/server/apis/bundle-diff.d.ts

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class BundleDiffAPI extends BaseAPI {
+    getBundleDiffSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetBundleDiffSummary>>;
+    bundleDiffManifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.BundleDiffManifest>>;
+}

package/dist/sdk/server/apis/bundle-diff.js

@@ -0,0 +1,51 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class BundleDiffAPI extends BaseAPI {
+    async getBundleDiffSummary() {
+        const { sdk } = this.ctx;
+        const { root, hash, errors, chunkGraph, moduleGraph, packageGraph, configs, moduleCodeMap, cloudManifestUrl } = sdk.getStoreData();
+        let outputFilename = '';
+        if ('string' == typeof configs?.[0]?.config?.output?.filename) outputFilename = configs?.[0]?.config?.output?.filename;
+        return {
+            root,
+            hash,
+            errors,
+            chunkGraph,
+            moduleGraph,
+            packageGraph,
+            outputFilename,
+            moduleCodeMap,
+            cloudManifestUrl
+        };
+    }
+    async bundleDiffManifest() {
+        const { sdk } = this.ctx;
+        const data = sdk.getStoreData();
+        return data;
+    }
+}
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.GetBundleDiffSummary),
+    Router.post(SDK.ServerAPI.API.GetBundleDiffSummary),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], BundleDiffAPI.prototype, "getBundleDiffSummary", null);
+_ts_decorate([
+    Router.get(SDK.ServerAPI.API.BundleDiffManifest),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], BundleDiffAPI.prototype, "bundleDiffManifest", null);
+export { BundleDiffAPI };

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

@@ -0,0 +1,6 @@
+import { SDK } from '@rsdoctor/shared/types';
+import { BaseAPI } from './base.js';
+export declare class DataAPI extends BaseAPI {
+    loadDataByKey(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.LoadDataByKey>>;
+    sendMessageToClient(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.SendAPIDataToClient>>;
+}

package/dist/sdk/server/apis/data.js

@@ -0,0 +1,44 @@
+import "node:module";
+import { SDK } from "@rsdoctor/shared/types";
+import { BaseAPI } from "./base.js";
+import { Router } from "../router.js";
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class DataAPI extends BaseAPI {
+    async loadDataByKey() {
+        const { req } = this.ctx;
+        const { url } = req;
+        let { key } = req.body;
+        if (!key && url) {
+            const uri = new URL(url, 'http://127.0.0.1');
+            key = uri.pathname.replace(/^\//, '');
+        }
+        const data = await this.loadData(key);
+        return data;
+    }
+    async sendMessageToClient() {
+        const { req, server } = this.ctx;
+        const { api, data } = req.body;
+        await server.sendAPIDataToClient(api, data);
+    }
+}
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.LoadDataByKey),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], DataAPI.prototype, "loadDataByKey", null);
+_ts_decorate([
+    Router.post(SDK.ServerAPI.API.SendAPIDataToClient),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], DataAPI.prototype, "sendMessageToClient", null);
+export { DataAPI };

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

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