@rsdoctor/utils 0.0.2-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# Rsdoctor
+
+Rsdoctor is a tool for diagnosing and analyzing the build process and build artifacts to help developers quickly identify and solve problems.
+
+It also supports Webpack and Rspack builders, as well as various build frameworks, such as Rsbuild.
+
+## Documentation
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/rsdoctor/blob/main/CONTRIBUTING.md).
+
+## License
+
+Rsdoctor is [MIT licensed](https://github.com/web-infra-dev/rsdoctor/blob/main/LICENSE).

package/dist/cjs/build/envinfo.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var envinfo_exports = {};
+__export(envinfo_exports, {
+  getCPUInfo: () => getCPUInfo,
+  getGitBranch: () => getGitBranch,
+  getGitRepo: () => getGitRepo,
+  getGlobalNpmPackageVersion: () => getGlobalNpmPackageVersion,
+  getMemoryInfo: () => getMemoryInfo,
+  getNodeVersion: () => getNodeVersion,
+  getNpmPackageVersion: () => getNpmPackageVersion,
+  getNpmVersion: () => getNpmVersion,
+  getOSInfo: () => getOSInfo,
+  getYarnVersion: () => getYarnVersion
+});
+module.exports = __toCommonJS(envinfo_exports);
+var import_envinfo = require("envinfo");
+var import_child_process = require("child_process");
+const getCPUInfo = () => import_envinfo.helpers.getCPUInfo().then((res) => res[1]);
+const getOSInfo = () => import_envinfo.helpers.getOSInfo().then((res) => res[1]);
+const getMemoryInfo = () => import_envinfo.helpers.getMemoryInfo().then((res) => res[1]);
+const getNodeVersion = () => import_envinfo.helpers.getNodeInfo().then((res) => res[1]);
+const getYarnVersion = () => import_envinfo.helpers.getYarnInfo().then((res) => res[1]);
+const getNpmVersion = () => import_envinfo.helpers.getnpmInfo().then((res) => res[1]);
+function getNpmPackageVersion(pkg) {
+  const isArray = Array.isArray(pkg);
+  return (0, import_envinfo.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 (0, import_envinfo.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) => {
+    (0, import_child_process.exec)("git branch --show-current", (err, stdout) => {
+      if (err) {
+        (0, import_child_process.exec)("git branch", (err2, stdout2) => {
+          if (err2) {
+            reject(err2);
+          } else {
+            resolve(
+              stdout2.split("\n").map((e) => e.replace("* ", "")).join("").trim()
+            );
+          }
+        });
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+function getGitRepo() {
+  return new Promise((resolve, reject) => {
+    (0, import_child_process.exec)("git config --get remote.origin.url", (err, stdout) => {
+      if (err)
+        reject(err);
+      else
+        resolve(stdout.trim());
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCPUInfo,
+  getGitBranch,
+  getGitRepo,
+  getGlobalNpmPackageVersion,
+  getMemoryInfo,
+  getNodeVersion,
+  getNpmPackageVersion,
+  getNpmVersion,
+  getOSInfo,
+  getYarnVersion
+});

package/dist/cjs/build/file/cache.js

@@ -0,0 +1,67 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  readFile: () => readFile,
+  readFileSync: () => readFileSync,
+  readJSON: () => readJSON,
+  readJSONSync: () => readJSONSync
+});
+module.exports = __toCommonJS(cache_exports);
+var import_fs_extra = __toESM(require("fs-extra"));
+const cache = /* @__PURE__ */ new Map();
+async function readFile(path) {
+  if (cache.has(path))
+    return cache.get(path);
+  const res = await import_fs_extra.default.readFile(path, "utf-8");
+  cache.set(path, res);
+  return res;
+}
+function readFileSync(path) {
+  if (cache.has(path))
+    return cache.get(path);
+  const res = import_fs_extra.default.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readFile,
+  readFileSync,
+  readJSON,
+  readJSONSync
+});

package/dist/cjs/build/file/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_exports = {};
+__export(file_exports, {
+  cache: () => cache,
+  fse: () => fse
+});
+module.exports = __toCommonJS(file_exports);
+__reExport(file_exports, require("./sharding"), module.exports);
+var fse = __toESM(require("fs-extra"));
+var cache = __toESM(require("./cache"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cache,
+  fse,
+  ...require("./sharding")
+});

package/dist/cjs/build/file/sharding.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sharding_exports = {};
+__export(sharding_exports, {
+  FileSharding: () => FileSharding
+});
+module.exports = __toCommonJS(sharding_exports);
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+class FileSharding {
+  constructor(content, limitBytes = 1024 * 1024 * 10, encoding = "utf-8") {
+    this.content = content;
+    this.limitBytes = limitBytes;
+    this.encoding = encoding;
+  }
+  /**
+   * @param ext the extension name of the output file (must starts with ".")
+   */
+  createVirtualShardingFiles(ext = "") {
+    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}${ext}`, content: e }));
+  }
+  /**
+   * @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 ".")
+   */
+  async writeStringToFolder(folder, ext = "") {
+    const dist = import_path.default.resolve(folder);
+    await import_fs_extra.default.ensureDir(dist);
+    const res = this.createVirtualShardingFiles(ext);
+    await Promise.all(
+      res.map(
+        (e) => new Promise((resolve, reject) => {
+          const stream = import_fs.default.createWriteStream(
+            import_path.default.join(dist, e.filename),
+            this.encoding
+          );
+          stream.end(e.content);
+          stream.once("close", () => resolve(void 0));
+          stream.once("error", (err) => reject(err));
+        })
+      )
+    );
+    return res;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileSharding
+});

package/dist/cjs/build/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var build_exports = {};
+__export(build_exports, {
+  EnvInfo: () => EnvInfo,
+  File: () => File,
+  Json: () => Json,
+  Process: () => Process,
+  Server: () => Server
+});
+module.exports = __toCommonJS(build_exports);
+var File = __toESM(require("./file"));
+var Json = __toESM(require("./json"));
+var Server = __toESM(require("./server"));
+var EnvInfo = __toESM(require("./envinfo"));
+var Process = __toESM(require("./process"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnvInfo,
+  File,
+  Json,
+  Process,
+  Server
+});

package/dist/cjs/build/json.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_exports = {};
+__export(json_exports, {
+  stringify: () => stringify
+});
+module.exports = __toCommonJS(json_exports);
+var import_json_stream_stringify = require("json-stream-stringify");
+var import_stream = require("stream");
+function stringify(json, replacer, space, cycle) {
+  if (json && typeof json === "object") {
+    return new Promise((resolve, reject) => {
+      let res = "";
+      const pt = new import_stream.PassThrough();
+      const stream = new import_json_stream_stringify.JsonStreamStringify(json, replacer, space, cycle);
+      pt.on("data", (chunk) => {
+        res += chunk;
+      });
+      pt.on("end", () => {
+        return resolve(res);
+      });
+      pt.on("error", (err) => {
+        return reject(err);
+      });
+      stream.on("error", (err) => {
+        return reject(err);
+      });
+      stream.pipe(pt);
+    });
+  }
+  return Promise.resolve(JSON.stringify(json, replacer, space));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stringify
+});

package/dist/cjs/build/process.js

@@ -0,0 +1,59 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var process_exports = {};
+__export(process_exports, {
+  getMemoryUsage: () => getMemoryUsage,
+  getMemoryUsageMessage: () => getMemoryUsageMessage
+});
+module.exports = __toCommonJS(process_exports);
+var import_bytes = __toESM(require("bytes"));
+var import_process = require("process");
+function getMemoryUsage() {
+  return (0, import_process.memoryUsage)();
+}
+function getMemoryUsageMessage() {
+  const usage = getMemoryUsage();
+  const msgs = [
+    `RSS: ${(0, import_bytes.default)(usage.rss)}`,
+    `Heap Total: ${(0, import_bytes.default)(usage.heapTotal)}`,
+    `Heap Used: ${(0, import_bytes.default)(usage.heapUsed)}`
+  ];
+  if (usage.arrayBuffers) {
+    msgs.push(`ArrayBuffers: ${(0, import_bytes.default)(usage.arrayBuffers)}`);
+  }
+  if (usage.external) {
+    msgs.push(`External: ${(0, import_bytes.default)(usage.external)}`);
+  }
+  return `["${import_process.pid}" Memory Usage] ${msgs.join(", ")}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMemoryUsage,
+  getMemoryUsageMessage
+});

package/dist/cjs/build/server.js

@@ -0,0 +1,127 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  createApp: () => createApp,
+  createGetPortSyncFunctionString: () => createGetPortSyncFunctionString,
+  createServer: () => createServer,
+  defaultPort: () => defaultPort,
+  getPort: () => getPort,
+  getPortSync: () => getPortSync
+});
+module.exports = __toCommonJS(server_exports);
+var import_connect = __toESM(require("connect"));
+var import_http = __toESM(require("http"));
+var import_os = __toESM(require("os"));
+var import_get_port = __toESM(require("get-port"));
+var import_child_process = require("child_process");
+var import_algorithm = require("../common/algorithm");
+const defaultPort = (0, import_algorithm.random)(3e3, 8999);
+async function getPort(expectPort) {
+  return (0, import_get_port.default)({ port: expectPort });
+}
+const createGetPortSyncFunctionString = (expectPort) => `
+(() => {
+const net = require('net');
+
+function getPort(expectPort) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on('error', reject);
+    server.listen(expectPort, () => {
+      const { port } = server.address();
+      server.close(() => {
+        resolve(port);
+      });
+    });
+  });
+}
+
+async function getAvailablePort(expectPort) {
+  let port = expectPort;
+  while (true) {
+    try {
+      const res = await getPort(port);
+      return res;
+    } catch (error) {
+      port += Math.floor(Math.random() * 100 + 1);
+    }
+  }
+}
+
+getAvailablePort(${expectPort}).then(port => process.stdout.write(port.toString()));
+})();
+`.trim();
+function getPortSync(expectPort) {
+  const statement = import_os.default.EOL === "\n" ? createGetPortSyncFunctionString(expectPort) : createGetPortSyncFunctionString(expectPort).replace(/\n/g, "");
+  const port = (0, import_child_process.execSync)(`node -e "${statement}"`, { encoding: "utf-8" });
+  return Number(port);
+}
+function createApp() {
+  return (0, import_connect.default)();
+}
+async function createServer(port) {
+  const app = createApp();
+  const server = import_http.default.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) => {
+    server.listen(port, () => {
+      resolve(res);
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApp,
+  createGetPortSyncFunctionString,
+  createServer,
+  defaultPort,
+  getPort,
+  getPortSync
+});

package/dist/cjs/common/alerts.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var alerts_exports = {};
+__export(alerts_exports, {
+  getPackageRelationAlertDetails: () => getPackageRelationAlertDetails
+});
+module.exports = __toCommonJS(alerts_exports);
+var import_path = require("path");
+function getPackageRelationAlertDetails(modules, dependencies, root, packageDependencies, moduleCodeMap) {
+  return packageDependencies.slice().reverse().map((dep) => {
+    const dependency = dependencies.find(
+      (item) => item.id === dep.dependencyId
+    );
+    if (!dependency) {
+      return null;
+    }
+    const module2 = modules.find((item) => item.id === dependency.module);
+    if (!module2) {
+      return null;
+    }
+    return {
+      group: dep.group,
+      module: module2,
+      dependency,
+      relativePath: (0, import_path.relative)(root, module2.path),
+      moduleCode: moduleCodeMap?.[module2.id]
+    };
+  }).filter(Boolean);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPackageRelationAlertDetails
+});