@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/cjs/rule-utils/parser/utils.js

@@ -0,0 +1,197 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  canParse: () => canParse,
+  detectECMAVersion: () => detectECMAVersion,
+  getDefaultImports: () => getDefaultImports,
+  getIdentifierInDeclaration: () => getIdentifierInDeclaration,
+  getIdentifierInExport: () => getIdentifierInExport,
+  getIdentifierInImport: () => getIdentifierInImport,
+  getIdentifierInPattern: () => getIdentifierInPattern,
+  isES5: () => isES5,
+  isES6: () => isES6,
+  isSameSemantics: () => isSameSemantics
+});
+module.exports = __toCommonJS(utils_exports);
+var import_acorn = require("acorn");
+var import_types = require("./types");
+var import_asserts = require("./asserts");
+function isSameSemantics(node1, node2) {
+  if (node1.type !== node2.type) {
+    return false;
+  }
+  switch (node1.type) {
+    case "CallExpression": {
+      const next = node2;
+      return node1.arguments.length === next.arguments.length && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.callee, next.callee) && node1.arguments.every(
+        (node, i) => isSameSemantics(node, next.arguments[i])
+      );
+    }
+    case "MemberExpression": {
+      const next = node2;
+      return node1.computed === next.computed && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.object, next.object) && isSameSemantics(node1.property, next.property);
+    }
+    case "Identifier": {
+      return node1.name === node2.name;
+    }
+    case "Literal": {
+      if (import_asserts.asserts.isSimpleLiteral(node1) && import_asserts.asserts.isSimpleLiteral(node2)) {
+        return node1.value === node2.value;
+      }
+      return node1.raw === node2.raw;
+    }
+    case "ObjectExpression": {
+      const next = node2;
+      return node1.properties.length === next.properties.length && node1.properties.every(
+        (prop, i) => isSameSemantics(prop, next.properties[i])
+      );
+    }
+    case "Property": {
+      const next = node2;
+      return node1.computed === next.computed && node1.kind === next.kind && node1.method === next.method && isSameSemantics(node1.key, next.key) && isSameSemantics(node1.value, next.value);
+    }
+    default: {
+      throw new Error(`Unknown node type: ${node1.type}`);
+    }
+  }
+}
+function getDefaultImports(node) {
+  return node.body.filter((statement) => {
+    if (statement.type !== "ImportDeclaration") {
+      return false;
+    }
+    const specifier = statement?.specifiers?.[0];
+    if (specifier?.type === "ImportDefaultSpecifier") {
+      return true;
+    }
+    return false;
+  });
+}
+function getIdentifierInPattern(name, node) {
+  if (import_asserts.asserts.isIdentifier(node) && node.name === name) {
+    return node;
+  }
+  if (import_asserts.asserts.isObjectPattern(node)) {
+    for (const prop of node.properties) {
+      if (import_asserts.asserts.isAssignmentProperty(prop)) {
+        return getIdentifierInPattern(name, prop.value);
+      }
+      if (import_asserts.asserts.isRestElement(prop)) {
+        return getIdentifierInPattern(name, prop);
+      }
+    }
+  }
+  if (import_asserts.asserts.isArrayPattern(node)) {
+    for (const el of node.elements) {
+      if (el) {
+        const result = getIdentifierInPattern(name, el);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+  if (import_asserts.asserts.isRestElement(node)) {
+    return getIdentifierInPattern(name, node.argument);
+  }
+  if (import_asserts.asserts.isAssignmentPattern(node)) {
+    return getIdentifierInPattern(name, node.left);
+  }
+}
+function getIdentifierInDeclaration(name, node) {
+  function getId(node2) {
+    return import_asserts.asserts.isIdentifier(node2.id) && node2.id.name === name ? node2.id : void 0;
+  }
+  if (import_asserts.asserts.isFunctionDeclaration(node)) {
+    return getId(node);
+  }
+  if (import_asserts.asserts.isClassDeclaration(node)) {
+    return getId(node);
+  }
+  if (import_asserts.asserts.isVariableDeclaration(node)) {
+    return node.declarations.find(
+      (item) => getIdentifierInPattern(name, item.id)
+    )?.id;
+  }
+}
+function getIdentifierInImport(name, node) {
+  if (import_asserts.asserts.isImportDeclaration(node)) {
+    for (const specifier of node.specifiers ?? []) {
+      if (specifier.local.name === name) {
+        return specifier.local;
+      }
+    }
+  }
+}
+function getIdentifierInExport(name, node) {
+  if (import_asserts.asserts.isExportNamedDeclaration(node)) {
+    if (node.declaration) {
+      return getIdentifierInDeclaration(name, node.declaration);
+    }
+    for (const specifier of node.specifiers ?? []) {
+      if (specifier.exported.name === name) {
+        return specifier.exported;
+      }
+    }
+  }
+  if (import_asserts.asserts.isExportAllDeclaration(node) && node.exported) {
+    if (node.exported.name === name) {
+      return node.exported;
+    }
+  }
+}
+function canParse(code, ecmaVersion2) {
+  try {
+    (0, import_acorn.parse)(code, {
+      ecmaVersion: ecmaVersion2,
+      sourceType: typeof ecmaVersion2 === "number" && ecmaVersion2 <= 5 ? "script" : "module"
+    });
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function isES5(code) {
+  return canParse(code, 5);
+}
+function isES6(code) {
+  return canParse(code, 6);
+}
+function detectECMAVersion(code) {
+  if (isES6(code)) {
+    if (isES5(code))
+      return import_types.ECMAVersion.ES5;
+    return import_types.ECMAVersion.ES6;
+  }
+  return import_types.ECMAVersion.ES7P;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  canParse,
+  detectECMAVersion,
+  getDefaultImports,
+  getIdentifierInDeclaration,
+  getIdentifierInExport,
+  getIdentifierInImport,
+  getIdentifierInPattern,
+  isES5,
+  isES6,
+  isSameSemantics
+});

package/dist/esm/build/envinfo.js

@@ -0,0 +1,75 @@
+import { helpers, run } from "envinfo";
+import { exec } from "child_process";
+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", (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) => {
+    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/esm/build/file/cache.js

@@ -0,0 +1,30 @@
+import fse from "fs-extra";
+const cache = /* @__PURE__ */ new Map();
+async function readFile(path) {
+  if (cache.has(path))
+    return cache.get(path);
+  const res = await fse.readFile(path, "utf-8");
+  cache.set(path, res);
+  return res;
+}
+function readFileSync(path) {
+  if (cache.has(path))
+    return cache.get(path);
+  const res = fse.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/esm/build/file/index.js

@@ -0,0 +1,7 @@
+export * from "./sharding";
+import * as fse from "fs-extra";
+import * as cache from "./cache";
+export {
+  cache,
+  fse
+};

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

@@ -0,0 +1,50 @@
+import fse from "fs-extra";
+import fs from "fs";
+import path from "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 = path.resolve(folder);
+    await fse.ensureDir(dist);
+    const res = this.createVirtualShardingFiles(ext);
+    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;
+  }
+}
+export {
+  FileSharding
+};

package/dist/esm/build/index.js

@@ -0,0 +1,12 @@
+import * as File from "./file";
+import * as Json from "./json";
+import * as Server from "./server";
+import * as EnvInfo from "./envinfo";
+import * as Process from "./process";
+export {
+  EnvInfo,
+  File,
+  Json,
+  Process,
+  Server
+};

package/dist/esm/build/json.js

@@ -0,0 +1,28 @@
+import { JsonStreamStringify } from "json-stream-stringify";
+import { PassThrough } from "stream";
+function stringify(json, replacer, space, cycle) {
+  if (json && typeof json === "object") {
+    return new Promise((resolve, reject) => {
+      let res = "";
+      const pt = new PassThrough();
+      const stream = new 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));
+}
+export {
+  stringify
+};

package/dist/esm/build/process.js

@@ -0,0 +1,24 @@
+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/esm/build/server.js

@@ -0,0 +1,88 @@
+import connect from "connect";
+import http from "http";
+import os from "os";
+import gp from "get-port";
+import { execSync } from "child_process";
+import { random } from "../common/algorithm";
+const defaultPort = random(3e3, 8999);
+async function getPort(expectPort) {
+  return gp({ 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 = os.EOL === "\n" ? createGetPortSyncFunctionString(expectPort) : createGetPortSyncFunctionString(expectPort).replace(/\n/g, "");
+  const port = execSync(`node -e "${statement}"`, { encoding: "utf-8" });
+  return Number(port);
+}
+function createApp() {
+  return connect();
+}
+async function createServer(port) {
+  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) => {
+    server.listen(port, () => {
+      resolve(res);
+    });
+  });
+}
+export {
+  createApp,
+  createGetPortSyncFunctionString,
+  createServer,
+  defaultPort,
+  getPort,
+  getPortSync
+};

package/dist/esm/common/alerts.js

@@ -0,0 +1,25 @@
+import { relative } from "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 module = modules.find((item) => item.id === dependency.module);
+    if (!module) {
+      return null;
+    }
+    return {
+      group: dep.group,
+      module,
+      dependency,
+      relativePath: relative(root, module.path),
+      moduleCode: moduleCodeMap?.[module.id]
+    };
+  }).filter(Boolean);
+}
+export {
+  getPackageRelationAlertDetails
+};

package/dist/esm/common/algorithm.js

@@ -0,0 +1,33 @@
+import { deflateSync, inflateSync } from "zlib";
+import { Buffer } from "buffer";
+function mergeIntervals(intervals) {
+  intervals.sort((a, b) => a[0] - b[0]);
+  let previous;
+  let current;
+  const result = [];
+  for (let i = 0; i < intervals.length; i++) {
+    current = intervals[i];
+    if (!previous || current[0] > previous[1]) {
+      previous = current;
+      result.push(current);
+    } else {
+      previous[1] = Math.max(previous[1], current[1]);
+    }
+  }
+  return result;
+}
+function compressText(input) {
+  return deflateSync(input).toString("base64");
+}
+function decompressText(input) {
+  return inflateSync(Buffer.from(input, "base64")).toString();
+}
+function random(min, max) {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+}
+export {
+  compressText,
+  decompressText,
+  mergeIntervals,
+  random
+};

package/dist/esm/common/bundle.js

@@ -0,0 +1,30 @@
+import { Client } from "@rsdoctor/types";
+const sep = ",";
+function getBundleDiffPageQueryString(files) {
+  let qs = encodeURIComponent(files.join(sep));
+  if (qs) {
+    qs = `?${Client.RsdoctorClientUrlQuery.BundleDiffFiles}=${qs}`;
+  }
+  return qs;
+}
+function getBundleDiffPageUrl(files) {
+  let qs = getBundleDiffPageQueryString(files);
+  if (process.env.NODE_ENV === "development") {
+    if (typeof location !== "undefined") {
+      const { search = "", origin } = location;
+      if (search) {
+        qs += `&${search.slice(1)}`;
+      }
+      return `${origin}${qs}#${Client.RsdoctorClientRoutes.BundleDiff}`;
+    }
+  }
+  return `${qs}#${Client.RsdoctorClientRoutes.BundleDiff}`;
+}
+function parseFilesFromBundlePageUrlQuery(queryValue) {
+  return decodeURIComponent(queryValue).split(sep);
+}
+export {
+  getBundleDiffPageQueryString,
+  getBundleDiffPageUrl,
+  parseFilesFromBundlePageUrlQuery
+};

package/dist/esm/common/crypto.js

@@ -0,0 +1,28 @@
+const sep = "!";
+function encode(str) {
+  let res = `${str.charCodeAt(0)}`;
+  for (let i = 1; i < str.length; i++) {
+    res += `${sep}${str.charCodeAt(i)}`;
+  }
+  return res;
+}
+function decode(str) {
+  let res = "";
+  let tmp = "";
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === sep) {
+      res += String.fromCharCode(+tmp);
+      tmp = "";
+    } else {
+      tmp += str[i];
+    }
+  }
+  if (tmp) {
+    res += String.fromCharCode(+tmp);
+  }
+  return res;
+}
+export {
+  decode,
+  encode
+};