@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

package/dist/build-utils/build/chunks/assetsModules.d.ts

@@ -1,4 +1,4 @@
-import { SDK } from '@rsdoctor/types';
+import { SDK } from '@rsdoctor/shared/types';
 /**
  * Collects module size data from bundle assets, using source maps when available
  * and falling back to AST parsing for assets without source maps.

package/dist/build-utils/build/chunks/assetsModules.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Chunks } from "@rsdoctor/graph";
+import { Chunks } from "../../../graph/index.js";
 import { parseBundle } from "../utils/index.js";
 async function getAssetsModulesData(moduleGraph, chunkGraph, bundleDir, sourceMapSets, hasParseBundle = true, assetsWithoutSourceMap) {
     return Chunks.getAssetsModulesData(moduleGraph, chunkGraph, bundleDir, hasParseBundle ? {

package/dist/build-utils/build/chunks/index.d.ts

@@ -1,3 +1,2 @@
 export * from './assetsModules.js';
-export * from './chunkTransform.js';
 export * from './rspack/transform.js';

package/dist/build-utils/build/chunks/index.js

@@ -1,4 +1,3 @@
 import "node:module";
 export * from "./assetsModules.js";
-export * from "./chunkTransform.js";
 export * from "./rspack/transform.js";

package/dist/build-utils/build/chunks/rspack/transform.d.ts

@@ -1,4 +1,4 @@
-import { Plugin, SDK } from '@rsdoctor/types';
+import { Plugin, SDK } from '@rsdoctor/shared/types';
 /**
  * Patch native chunk graph data from Rspack into ChunkGraph instance
  * @param cg The ChunkGraph instance to be patched

package/dist/build-utils/build/chunks/rspack/transform.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Asset, Chunk, EntryPoint } from "@rsdoctor/graph";
+import { Asset, Chunk, EntryPoint } from "../../../../graph/index.js";
 function patchNativeChunkGraph(cg, rawChunkGraph) {
     const { chunks: rawChunks, entrypoints: rawEntrypoints } = rawChunkGraph;
     const chunks = rawChunks.map((chunk)=>new Chunk(chunk.ukey.toString(), chunk.name, 0, chunk.initial, chunk.entry));

package/dist/build-utils/build/envinfo.d.ts

@@ -0,0 +1,13 @@
+export declare const getCPUInfo: () => Promise<string>;
+export declare const getOSInfo: () => Promise<string>;
+export declare const getMemoryInfo: () => Promise<string>;
+export declare const getNodeVersion: () => Promise<string>;
+export declare const getYarnVersion: () => Promise<string>;
+export declare const getNpmVersion: () => Promise<string>;
+export declare const getPnpmVersion: () => Promise<string>;
+export declare function getNpmPackageVersion(pkg: string): Promise<string>;
+export declare function getNpmPackageVersion(pkgs: string[]): Promise<string[]>;
+export declare function getGlobalNpmPackageVersion(pkg: string): Promise<string>;
+export declare function getGlobalNpmPackageVersion(pkgs: string[]): Promise<string[]>;
+export declare function getGitBranch(): Promise<string>;
+export declare function getGitRepo(): Promise<string>;

package/dist/build-utils/build/envinfo.js

@@ -0,0 +1,60 @@
+import "node:module";
+import envinfo from "envinfo";
+import { exec } from "child_process";
+const helpers = envinfo.helpers;
+const run = envinfo.run;
+const getCPUInfo = ()=>helpers.getCPUInfo().then((res)=>res[1]);
+const getOSInfo = ()=>helpers.getOSInfo().then((res)=>res[1]);
+const getMemoryInfo = ()=>helpers.getMemoryInfo().then((res)=>res[1]);
+const getNodeVersion = ()=>helpers.getNodeInfo().then((res)=>res[1]);
+const getYarnVersion = ()=>helpers.getYarnInfo().then((res)=>res[1]);
+const getNpmVersion = ()=>helpers.getnpmInfo().then((res)=>res[1]);
+const getPnpmVersion = ()=>helpers.getpnpmInfo().then((res)=>res[1]);
+function getNpmPackageVersion(pkg) {
+    const isArray = Array.isArray(pkg);
+    return run({
+        npmPackages: isArray ? pkg : [
+            pkg
+        ]
+    }, {
+        json: true,
+        showNotFound: true
+    }).then((res)=>{
+        const { npmPackages = {} } = JSON.parse(res) || {};
+        return isArray ? pkg.map((e)=>npmPackages[e] || 'Not Found') : npmPackages[pkg];
+    });
+}
+function getGlobalNpmPackageVersion(pkg) {
+    const isArray = Array.isArray(pkg);
+    return run({
+        npmGlobalPackages: isArray ? pkg : [
+            pkg
+        ]
+    }, {
+        json: true,
+        showNotFound: true
+    }).then((res)=>{
+        const { npmGlobalPackages = {} } = JSON.parse(res) || {};
+        return isArray ? pkg.map((e)=>npmGlobalPackages[e] || 'Not Found') : npmGlobalPackages[pkg];
+    });
+}
+function getGitBranch() {
+    return new Promise((resolve, reject)=>{
+        exec('git branch --show-current', (err, stdout)=>{
+            if (err) exec('git branch', (err, stdout)=>{
+                if (err) reject(err);
+                else resolve(stdout.split('\n').map((e)=>e.replace('* ', '')).join('').trim());
+            });
+            else resolve(stdout.trim());
+        });
+    });
+}
+function getGitRepo() {
+    return new Promise((resolve, reject)=>{
+        exec('git config --get remote.origin.url', (err, stdout)=>{
+            if (err) reject(err);
+            else resolve(stdout.trim());
+        });
+    });
+}
+export { getCPUInfo, getGitBranch, getGitRepo, getGlobalNpmPackageVersion, getMemoryInfo, getNodeVersion, getNpmPackageVersion, getNpmVersion, getOSInfo, getPnpmVersion, getYarnVersion };

package/dist/build-utils/build/file/cache.d.ts

@@ -0,0 +1,5 @@
+import { Common } from '@rsdoctor/shared/types';
+export declare function readFile(path: string): Promise<string>;
+export declare function readFileSync(path: string): string;
+export declare function readJSON<T extends Common.PlainObject>(path: string): Promise<T>;
+export declare function readJSONSync<T extends Common.PlainObject>(path: string): T;

package/dist/build-utils/build/file/cache.js

@@ -0,0 +1,24 @@
+import "node:module";
+import node_fs from "node:fs";
+const cache = new Map();
+async function readFile(path) {
+    if (cache.has(path)) return cache.get(path);
+    const res = await node_fs.promises.readFile(path, 'utf-8');
+    cache.set(path, res);
+    return res;
+}
+function readFileSync(path) {
+    if (cache.has(path)) return cache.get(path);
+    const res = node_fs.readFileSync(path, 'utf-8');
+    cache.set(path, res);
+    return res;
+}
+async function readJSON(path) {
+    const str = await readFile(path);
+    return JSON.parse(str);
+}
+function readJSONSync(path) {
+    const str = readFileSync(path);
+    return JSON.parse(str);
+}
+export { readFile, readFileSync, readJSON, readJSONSync };

package/dist/build-utils/build/file/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sharding.js';
+export { default as fse } from 'fs-extra';
+export * as cache from './cache.js';

package/dist/build-utils/build/file/index.js

@@ -0,0 +1,5 @@
+import "node:module";
+import * as __rspack_external__cache_js_3b19274f from "./cache.js";
+export * from "./sharding.js";
+export { default as fse } from "fs-extra";
+export { __rspack_external__cache_js_3b19274f as cache };

package/dist/build-utils/build/file/sharding.d.ts

@@ -0,0 +1,21 @@
+export declare class FileSharding {
+    protected content: string;
+    protected limitBytes: number;
+    protected encoding: BufferEncoding;
+    constructor(content: string, limitBytes?: number, encoding?: BufferEncoding);
+    /**
+     * @param ext the extension name of the output file (must starts with ".")
+     */
+    createVirtualShardingFiles(ext?: string, index?: number): {
+        filename: string;
+        content: Buffer<ArrayBufferLike>;
+    }[];
+    /**
+     * @param folder absolute path of folder which used to save string sharding files.
+     * @param ext the extension name of the output file (must starts with ".")
+     */
+    writeStringToFolder(folder: string, ext?: string, index?: number): Promise<{
+        filename: string;
+        content: Buffer<ArrayBufferLike>;
+    }[]>;
+}

package/dist/build-utils/build/file/sharding.js

@@ -0,0 +1,38 @@
+import "node:module";
+import fs_extra from "fs-extra";
+import fs from "fs";
+import path from "path";
+class FileSharding {
+    createVirtualShardingFiles(ext = '', index = 0) {
+        const bf = Buffer.from(this.content, this.encoding);
+        const res = [];
+        const threshold = this.limitBytes;
+        let tmpBytes = 0;
+        while(bf.byteLength > tmpBytes){
+            res.push(bf.subarray(tmpBytes, tmpBytes + threshold));
+            tmpBytes += threshold;
+        }
+        return res.map((e, i)=>({
+                filename: `${i + index}${ext}`,
+                content: e
+            }));
+    }
+    async writeStringToFolder(folder, ext = '', index) {
+        const dist = path.resolve(folder);
+        await fs_extra.ensureDir(dist);
+        const res = this.createVirtualShardingFiles(ext, index);
+        await Promise.all(res.map((e)=>new Promise((resolve, reject)=>{
+                const stream = fs.createWriteStream(path.join(dist, e.filename), this.encoding);
+                stream.end(e.content);
+                stream.once('close', ()=>resolve(void 0));
+                stream.once('error', (err)=>reject(err));
+            })));
+        return res;
+    }
+    constructor(content, limitBytes = 10485760, encoding = 'utf-8'){
+        this.content = content;
+        this.limitBytes = limitBytes;
+        this.encoding = encoding;
+    }
+}
+export { FileSharding };

package/dist/build-utils/build/index.d.ts

@@ -1,3 +1,8 @@
+export * as File from './file/index.js';
+export * as Json from './json.js';
+export * as Server from './server.js';
+export * as EnvInfo from './envinfo.js';
+export * as Process from './process.js';
 export * as Chunks from './chunks/index.js';
 export * as Utils from './utils/index.js';
 export * as Loader from './loader/index.js';

package/dist/build-utils/build/index.js

@@ -1,7 +1,12 @@
 import "node:module";
-import * as __rspack_external__chunks_index_js_0dff7c47 from "./chunks/index.js";
-import * as __rspack_external__utils_index_js_1ffdce1c from "./utils/index.js";
-import * as __rspack_external__loader_index_js_7618f2f0 from "./loader/index.js";
-import * as __rspack_external__types_index_js_def0ea92 from "../../types/index.js";
-import * as __rspack_external__module_graph_index_js_3ee70f67 from "./module-graph/index.js";
-export { __rspack_external__chunks_index_js_0dff7c47 as Chunks, __rspack_external__loader_index_js_7618f2f0 as Loader, __rspack_external__module_graph_index_js_3ee70f67 as ModuleGraph, __rspack_external__types_index_js_def0ea92 as Types, __rspack_external__utils_index_js_1ffdce1c as Utils };
+import * as __rspack_external__file_index_js_5cbcde29 from "./file/index.js";
+import * as __rspack_external__json_js_faef839e from "./json.js";
+import * as __rspack_external__server_js_186b33b9 from "./server.js";
+import * as __rspack_external__envinfo_js_2b90a03d from "./envinfo.js";
+import * as __rspack_external__process_js_7eda60d3 from "./process.js";
+import * as __rspack_external__chunks_index_js_c4bbc2de from "./chunks/index.js";
+import * as __rspack_external__utils_index_js_d2e4ad7a from "./utils/index.js";
+import * as __rspack_external__loader_index_js_ef25077c from "./loader/index.js";
+import * as __rspack_external__types_index_js_d78e4824 from "../../types/index.js";
+import * as __rspack_external__module_graph_index_js_f91481f4 from "./module-graph/index.js";
+export { __rspack_external__chunks_index_js_c4bbc2de as Chunks, __rspack_external__envinfo_js_2b90a03d as EnvInfo, __rspack_external__file_index_js_5cbcde29 as File, __rspack_external__json_js_faef839e as Json, __rspack_external__loader_index_js_ef25077c as Loader, __rspack_external__module_graph_index_js_f91481f4 as ModuleGraph, __rspack_external__process_js_7eda60d3 as Process, __rspack_external__server_js_186b33b9 as Server, __rspack_external__types_index_js_d78e4824 as Types, __rspack_external__utils_index_js_d2e4ad7a as Utils };

package/dist/build-utils/build/json.d.ts

@@ -0,0 +1,3 @@
+import { SDK } from '@rsdoctor/shared/types';
+export declare function stringify<T, P = T extends undefined ? undefined : string>(json: T, replacer?: (this: any, key: string, value: any) => any, space?: string | number, cycle?: boolean): Promise<P>;
+export declare const readPackageJson: (file: string, readFile?: SDK.GetPackageFile) => SDK.PackageBasicData | undefined;

package/dist/build-utils/build/json.js

@@ -0,0 +1,67 @@
+import "node:module";
+import { JsonStreamStringify } from "json-stream-stringify";
+import { dirname, join } from "path";
+import { Package } from "../../common/index.js";
+import { Transform } from "stream";
+const maxFileSize = 419430400;
+function stringify(json, replacer, space, cycle) {
+    const jsonList = [];
+    if (json && 'object' == typeof json) return new Promise((resolve, reject)=>{
+        const stream = new JsonStreamStringify(json, replacer, space, cycle);
+        let currentLength = 0;
+        let currentContent = '';
+        const batchProcessor = new Transform({
+            readableObjectMode: true,
+            transform (chunk, _encoding, callback) {
+                const lines = chunk.toString().split('\\n');
+                lines.forEach((line)=>{
+                    if (currentLength + line.length > maxFileSize) {
+                        jsonList.push(currentContent);
+                        currentContent = '';
+                        currentLength = 0;
+                    }
+                    if (line.length) {
+                        currentContent += line;
+                        currentLength += line.length;
+                    }
+                });
+                callback();
+            }
+        });
+        stream.pipe(batchProcessor).on('data', (line)=>{
+            if (currentLength + line.length > maxFileSize) {
+                jsonList.push(currentContent);
+                currentContent = '';
+                currentLength = 0;
+            }
+            if (line.length) {
+                currentContent += line;
+                currentLength += line.length;
+            }
+        }).on('end', ()=>{
+            if (jsonList.length < 1) jsonList.push(currentContent);
+            resolve(jsonList);
+        }).on('error', (err)=>reject(err));
+    });
+    return Promise.resolve(JSON.stringify(json, replacer, space));
+}
+const readPackageJson = (file, readFile)=>{
+    let result;
+    let current = file;
+    while('/' !== current && !result){
+        const parent = dirname(current);
+        if (parent === current) break;
+        current = parent;
+        if (readFile) result = readFile(join(current, 'package.json'));
+        if (readFile) {
+            if (!result?.name) result = void 0;
+        } else result = Package.getPackageMetaFromModulePath(file);
+    }
+    if (!result) return;
+    if (readFile && (!result.name || !result.version)) return readPackageJson(dirname(current), readFile);
+    return {
+        ...result,
+        root: current
+    };
+};
+export { readPackageJson, stringify };

package/dist/build-utils/build/loader/probeLoader.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import type { Plugin } from '@rsdoctor/shared/types';
 import type { LoaderDefinitionFunction } from '@rspack/core';
-export declare const loaderModule: Plugin.LoaderDefinition<Parameters<LoaderDefinitionFunction>, {}>;
+export declare const loaderModule: Plugin.LoaderDefinition<Parameters<LoaderDefinitionFunction>, object>;
 export default loaderModule;

package/dist/build-utils/build/loader/probeLoader.js

@@ -1,7 +1,7 @@
 import "node:module";
-import { Build } from "../../index.js";
-import { getSDK } from "../../../inner-plugins/index.js";
-import { omit } from "es-toolkit/compat";
+import { parseQuery } from "../utils/index.js";
+import { getSDK } from "../../../inner-plugins/utils/sdk.js";
+import { omit } from "../../../collection.js";
 import path from "path";
 const loaderModule = function(...args) {
     const time = Date.now();
@@ -11,7 +11,7 @@ const loaderModule = function(...args) {
     const loaderData = {
         resource: {
             path: this._module?.layer ? `${this.resourcePath}[${this._module.layer}]` : this.resourcePath,
-            query: Build.Utils.parseQuery(this.resourceQuery),
+            query: parseQuery(this.resourceQuery),
             queryRaw: this.resourceQuery,
             ext: path.extname(this.resourcePath).slice(1),
             ...this._module?.layer ? {

package/dist/build-utils/build/loader/probeLoaderPlugin.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '@rsdoctor/types';
+import type { Plugin } from '@rsdoctor/shared/types';
 export declare class ProbeLoaderPlugin {
     apply(compiler: Plugin.BaseCompiler): void;
     private addProbeLoader;

package/dist/build-utils/build/loader/probeLoaderPlugin.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { Loader } from "@rsdoctor/utils/common";
+import { Loader } from "../../../common/index.js";
 import { Build } from "../../index.js";
 import { Utils } from "../index.js";
 const BuiltinLoaderName = 'builtin:swc-loader';

package/dist/build-utils/build/module-graph/index.d.ts

@@ -1,4 +1 @@
-export * from './webpack/transform.js';
-export * from './transform.js';
-export * from './treeShaking.js';
 export * from './rspack/transform.js';

package/dist/build-utils/build/module-graph/index.js

@@ -1,5 +1,2 @@
 import "node:module";
-export * from "./webpack/transform.js";
-export * from "./transform.js";
-export * from "./treeShaking.js";
 export * from "./rspack/transform.js";

package/dist/build-utils/build/module-graph/parser.d.ts

@@ -1,2 +1,2 @@
-import { Node } from '@rsdoctor/utils/ruleUtils';
+import { Node } from '../../../rule-utils/index.js';
 export declare function hasSetEsModuleStatement(program: Node.Program): boolean;

package/dist/build-utils/build/module-graph/parser.js

@@ -1,5 +1,5 @@
 import "node:module";
-import { parser } from "@rsdoctor/utils/ruleUtils";
+import { parser } from "../../../rule-utils/index.js";
 const esmLabelStatement = parser.internal.parseExpressionAt('Object.defineProperty(exports, "__esModule", { value: true })', 0, {
     ecmaVersion: 6,
     ranges: false,

package/dist/build-utils/build/module-graph/rspack/transform.d.ts

@@ -1,4 +1,4 @@
-import { Plugin, SDK } from '@rsdoctor/types';
+import { Plugin, SDK } from '@rsdoctor/shared/types';
 /**
  * Patch native module graph data from Rspack into ModuleGraph instance
  * @param mg The ModuleGraph instance to be patched

package/dist/build-utils/build/module-graph/rspack/transform.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { Dependency, Module, extractCodeFromLocation, parseLocation } from "@rsdoctor/graph";
-import { SDK } from "@rsdoctor/types";
+import { Dependency, Module, extractCodeFromSourceLines, parseLocation } from "../../../../graph/index.js";
+import { SDK } from "@rsdoctor/shared/types";
 const createDependencyKind = (type)=>{
     if (type.includes('harmony') || 'esm import' === type) return SDK.DependencyKind.ImportStatement;
     if (type.includes('cjs')) return SDK.DependencyKind.RequireCall;
@@ -81,7 +81,7 @@ function patchNativeModuleSources(mg, rawModuleSourcesPatch) {
     }
     const jsonModuleSizes = rawModuleSourcesPatch.jsonModuleSizes;
     if (jsonModuleSizes && jsonModuleSizes.length > 0) for (const jsonModuleSize of jsonModuleSizes){
-        const module = mg.getModuleByWebpackId(jsonModuleSize.identifier);
+        const module = mg.getModuleByIdentifier(jsonModuleSize.identifier);
         if (module) module.setSize({
             parsedSize: jsonModuleSize.size
         });
@@ -94,10 +94,12 @@ function extractSideEffectCodes(mg) {
         if (!sideEffectLocations.length) continue;
         const moduleSource = module.getSource();
         const source = moduleSource.source || moduleSource.parsedSource;
-        if (source) for (const sideEffectLocation of sideEffectLocations){
+        if (!source) continue;
+        const sourceLines = source.split('\n');
+        for (const sideEffectLocation of sideEffectLocations){
             const parsedLocation = parseLocation(sideEffectLocation.location);
             if (!parsedLocation) continue;
-            const code = extractCodeFromLocation(source, parsedLocation);
+            const code = extractCodeFromSourceLines(sourceLines, parsedLocation);
             if (code) module.addSideEffectCode({
                 moduleId: module.id,
                 startLine: parsedLocation.startLine,

package/dist/build-utils/build/module-graph/utils.d.ts

@@ -1,3 +1,3 @@
-import { SDK } from '@rsdoctor/types';
+import { SDK } from '@rsdoctor/shared/types';
 export declare function getExportIdentifierStatement(name: string, module: SDK.ModuleInstance): SDK.StatementInstance | undefined;
 export declare function getDeclarationIdentifier(name: string, module: SDK.ModuleInstance): SDK.StatementInstance | undefined;

package/dist/build-utils/build/module-graph/utils.js

@@ -1,6 +1,5 @@
 import "node:module";
-import { isNumber } from "es-toolkit/compat";
-import { parser } from "@rsdoctor/utils/ruleUtils";
+import { parser } from "../../../rule-utils/index.js";
 function getDefaultExportIdentifier(node, module, searchId) {
     const { declaration } = node;
     if (parser.asserts.isLiteral(declaration) && declaration.loc) return module.getStatement(declaration.loc);
@@ -14,9 +13,11 @@ function getDefaultExportIdentifier(node, module, searchId) {
         if (declaration.id?.loc) return module.getStatement(declaration.id.loc);
     }
     const startLine = node.declaration.loc?.start.line;
-    if (!isNumber(startLine)) return;
+    if ('number' != typeof startLine) return;
     const { transformed } = module.getSource();
-    const endColumn = transformed.split('\n')[startLine - 1].length - 1;
+    const line = transformed.split('\n')[startLine - 1];
+    if (void 0 === line) return;
+    const endColumn = line.length - 1;
     return module.getStatement({
         start: {
             line: startLine,

package/dist/build-utils/build/process.d.ts

@@ -0,0 +1,2 @@
+export declare function getMemoryUsage(): NodeJS.MemoryUsage;
+export declare function getMemoryUsageMessage(): string;

package/dist/build-utils/build/process.js

@@ -0,0 +1,18 @@
+import "node:module";
+import { filesize } from "filesize";
+import { memoryUsage, pid } from "process";
+function getMemoryUsage() {
+    return memoryUsage();
+}
+function getMemoryUsageMessage() {
+    const usage = getMemoryUsage();
+    const msgs = [
+        `RSS: ${filesize(usage.rss)}`,
+        `Heap Total: ${filesize(usage.heapTotal)}`,
+        `Heap Used: ${filesize(usage.heapUsed)}`
+    ];
+    if (usage.arrayBuffers) msgs.push(`ArrayBuffers: ${filesize(usage.arrayBuffers)}`);
+    if (usage.external) msgs.push(`External: ${filesize(usage.external)}`);
+    return `["${pid}" Memory Usage] ${msgs.join(', ')}`;
+}
+export { getMemoryUsage, getMemoryUsageMessage };

package/dist/build-utils/build/server.d.ts

@@ -0,0 +1,15 @@
+import connect from 'connect';
+import http from 'http';
+import { Thirdparty } from '@rsdoctor/shared/types';
+export declare const defaultHost = "127.0.0.1";
+export declare const defaultPort: number;
+export declare function getPort(expectPort: number, host?: string): Promise<number>;
+export declare const createGetPortSyncFunctionString: (expectPort: number, host?: string) => string;
+export declare function getPortSync(expectPort: number, host?: string): number | never;
+export declare function createApp(): connect.Server;
+export declare function createServer(port: number, host?: string): Promise<{
+    app: Thirdparty.connect.Server;
+    server: http.Server;
+    port: number;
+    close(): Promise<void> | never;
+}>;

package/dist/build-utils/build/server.js

@@ -0,0 +1,107 @@
+import "node:module";
+import connect from "connect";
+import http from "http";
+import os from "os";
+import get_port from "get-port";
+import { execFileSync } from "child_process";
+import { Algorithm } from "../../common/index.js";
+const RESTRICTED_PORTS = [
+    3659,
+    4045,
+    6000,
+    6665,
+    6666,
+    6667,
+    6668,
+    6669
+];
+const defaultHost = '127.0.0.1';
+function getRandomPort(min, max) {
+    let port;
+    do port = Algorithm.random(min, max);
+    while (RESTRICTED_PORTS.includes(port));
+    return port;
+}
+const defaultPort = getRandomPort(3000, 8999);
+async function getPort(expectPort, host = defaultHost) {
+    return get_port({
+        port: expectPort,
+        host
+    });
+}
+const createGetPortSyncFunctionString = (expectPort, host = defaultHost)=>`
+(() => {
+const net = require('net');
+
+function getPort(expectPort, host) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on('error', reject);
+    server.listen(expectPort, host, () => {
+      const { port } = server.address();
+      server.close(() => {
+        resolve(port);
+      });
+    });
+  });
+}
+
+async function getAvailablePort(expectPort) {
+  let port = expectPort;
+  while (true) {
+    try {
+      const res = await getPort(port, ${JSON.stringify(host)});
+      return res;
+    } catch (error) {
+      port += Math.floor(Math.random() * 100 + 1);
+    }
+  }
+}
+
+getAvailablePort(${expectPort}).then(port => process.stdout.write(port.toString()));
+})();
+`.trim();
+function getPortSync(expectPort, host = defaultHost) {
+    const statement = '\n' === os.EOL ? createGetPortSyncFunctionString(expectPort, host) : createGetPortSyncFunctionString(expectPort, host).replace(/\n/g, '');
+    const port = execFileSync(process.execPath, [
+        '-e',
+        statement
+    ], {
+        encoding: 'utf-8'
+    });
+    return Number(port);
+}
+function createApp() {
+    return connect();
+}
+async function createServer(port, host = defaultHost) {
+    const app = createApp();
+    const server = http.createServer(app);
+    const res = {
+        app,
+        server,
+        port,
+        close () {
+            return new Promise((resolve, reject)=>{
+                if ('closeAllConnections' in server) server.closeAllConnections();
+                if ('closeIdleConnections' in server) server.closeIdleConnections();
+                server.close((err)=>{
+                    if (err) reject(err);
+                    resolve();
+                });
+            });
+        }
+    };
+    return new Promise((resolve, reject)=>{
+        const onError = (error)=>{
+            reject(error);
+        };
+        server.once('error', onError);
+        server.listen(port, host, ()=>{
+            server.off('error', onError);
+            resolve(res);
+        });
+    });
+}
+export { createApp, createGetPortSyncFunctionString, createServer, defaultHost, defaultPort, getPort, getPortSync };

package/dist/build-utils/build/utils/loader.d.ts

@@ -1,11 +1,11 @@
-import type { Common, Plugin } from '@rsdoctor/types';
+import type { Common, Plugin } from '@rsdoctor/shared/types';
 export declare function parsePathQueryFragment(str: string): {
     path: string;
     query: string;
     fragment: string;
 };
 export declare function loadLoaderModule(loaderPath: string, cwd?: string): {
-    default: Plugin.LoaderDefinition<Common.PlainObject, {}>;
+    default: Plugin.LoaderDefinition<Common.PlainObject, object>;
     pitch: Plugin.PitchLoaderDefinitionFunction;
     raw: boolean | void;
 };