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

package/dist/sdk/sdk/core.js

@@ -1,163 +0,0 @@
-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.js

@@ -1,435 +0,0 @@
-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.js

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

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

@@ -1,30 +0,0 @@
-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.js

@@ -1,22 +0,0 @@
-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 };