@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/esm/common/index.js

@@ -0,0 +1,32 @@
+import * as Summary from "./summary";
+import * as Crypto from "./crypto";
+import * as Manifest from "./manifest";
+import * as Loader from "./loader";
+import * as Time from "./time";
+import * as Algorithm from "./algorithm";
+import * as Resolver from "./resolver";
+import * as Graph from "./graph";
+import * as Bundle from "./bundle";
+import * as Url from "./url";
+import * as Plugin from "./plugin";
+import * as Data from "./data";
+import * as Alerts from "./alerts";
+import * as Rspack from "./rspack";
+import * as Package from "./package";
+export {
+  Alerts,
+  Algorithm,
+  Bundle,
+  Crypto,
+  Data,
+  Graph,
+  Loader,
+  Manifest,
+  Package,
+  Plugin,
+  Resolver,
+  Rspack,
+  Summary,
+  Time,
+  Url
+};

package/dist/esm/common/loader.js

@@ -0,0 +1,225 @@
+import { mergeIntervals } from "./algorithm";
+function findLoaderTotalTiming(loaders) {
+  let start = Infinity;
+  let end = -Infinity;
+  for (let i = 0; i < loaders.length; i++) {
+    const loader = loaders[i];
+    if (loader.startAt <= start) {
+      start = loader.startAt;
+    }
+    if (loader.endAt >= end) {
+      end = loader.endAt;
+    }
+  }
+  return {
+    start,
+    end
+  };
+}
+function getLoadersCosts(filter, loaders) {
+  const match = {};
+  const others = {};
+  loaders.forEach((e) => {
+    if (filter(e)) {
+      if (!match[e.pid])
+        match[e.pid] = [];
+      match[e.pid].push([e.startAt, e.endAt]);
+    } else {
+      if (!others[e.pid])
+        others[e.pid] = [];
+      others[e.pid].push([e.startAt, e.endAt]);
+    }
+  });
+  let costs = 0;
+  const pids = Object.keys(match);
+  for (let i = 0; i < pids.length; i++) {
+    const pid = pids[i];
+    const _match = mergeIntervals(match[pid]);
+    const _others = mergeIntervals(others[pid] || []).filter(
+      ([s, e]) => _match.some((el) => s >= el[0] && e <= el[1])
+    );
+    const matchSum = _match.length ? _match.reduce((t, c) => t += c[1] - c[0], 0) : 0;
+    const othersSum = _others.length ? _others.reduce((t, c) => t += c[1] - c[0], 0) : 0;
+    costs += matchSum - othersSum;
+  }
+  return costs;
+}
+function getLoaderCosts(loader, loaders) {
+  const blocked = loaders.filter((e) => {
+    if (e !== loader && e.pid === loader.pid) {
+      if (e.startAt >= loader.startAt) {
+        if (e.endAt <= loader.endAt)
+          return true;
+      }
+    }
+    return false;
+  });
+  let costs = loader.endAt - loader.startAt;
+  if (blocked.length) {
+    const intervals = blocked.map((e) => [
+      Math.max(e.startAt, loader.startAt),
+      Math.min(e.endAt, loader.endAt)
+    ]);
+    mergeIntervals(intervals).forEach((e) => {
+      const sub = e[1] - e[0];
+      costs -= sub;
+    });
+  }
+  return costs;
+}
+function getLoaderNames(loaders) {
+  const names = /* @__PURE__ */ new Set();
+  loaders.forEach((e) => e.loaders.forEach((l) => names.add(l.loader)));
+  return [...names];
+}
+function getLoadersTransformData(loaders) {
+  const res = [];
+  for (let i = 0; i < loaders.length; i++) {
+    const item = loaders[i];
+    for (let j = 0; j < item.loaders.length; j++) {
+      const loader = item.loaders[j];
+      res.push(loader);
+    }
+  }
+  return res;
+}
+function getLoaderChartData(loaders) {
+  const res = [];
+  const list = getLoadersTransformData(loaders);
+  loaders.forEach((item) => {
+    item.loaders.forEach((el) => {
+      res.push({
+        loader: el.loader,
+        isPitch: el.isPitch,
+        startAt: el.startAt,
+        endAt: el.endAt,
+        pid: el.pid,
+        sync: el.sync,
+        resource: item.resource.path,
+        costs: getLoaderCosts(el, list)
+      });
+    });
+  });
+  return res;
+}
+function getLoaderFileTree(loaders) {
+  const list = getLoadersTransformData(loaders);
+  return loaders.map((data) => {
+    const { loaders: arr, resource } = data;
+    return {
+      path: resource.path,
+      loaders: arr.map((l) => {
+        return {
+          loader: l.loader,
+          path: l.path,
+          errors: l.errors,
+          costs: getLoaderCosts(l, list)
+        };
+      })
+    };
+  });
+}
+function getLoaderFileDetails(path, loaders) {
+  const data = loaders.find((e) => e.resource.path === path);
+  if (!data) {
+    throw new Error(`"${path}" not match any loader data`);
+  }
+  const list = getLoadersTransformData(loaders);
+  return {
+    ...data,
+    loaders: data.loaders.map((el) => {
+      return {
+        ...el,
+        costs: getLoaderCosts(el, list)
+      };
+    })
+  };
+}
+function getLoaderFolderStatistics(folder, loaders) {
+  const datas = loaders.filter((data) => {
+    const { path } = data.resource;
+    return path.startsWith(folder);
+  });
+  const list = getLoadersTransformData(loaders);
+  return datas.reduce((t, data) => {
+    const { loaders: loaders2 } = data;
+    loaders2.forEach((l) => {
+      const match = t.find((el) => el.loader === l.loader);
+      const costs = getLoaderCosts(l, list);
+      if (match) {
+        match.files++;
+        match.costs += costs;
+      } else {
+        t.push({
+          loader: l.loader,
+          path: l.path,
+          files: 1,
+          costs
+        });
+      }
+    });
+    return t;
+  }, []);
+}
+function getLoaderFileFirstInput(file, loaders) {
+  for (let i = 0; i < loaders.length; i++) {
+    const item = loaders[i];
+    if (item.resource.path === file) {
+      const nonPitchLoaders = item.loaders.filter((e) => !e.isPitch);
+      if (!nonPitchLoaders.length)
+        return "";
+      return nonPitchLoaders[0].input || "";
+    }
+  }
+  return "";
+}
+function getLoaderFileInputAndOutput(file, loader, loaderIndex, loaders) {
+  for (let i = 0; i < loaders.length; i++) {
+    const item = loaders[i];
+    if (item.resource.path === file) {
+      for (let j = 0; j < item.loaders.length; j++) {
+        const l = item.loaders[j];
+        if (l.loader === loader && l.loaderIndex === loaderIndex) {
+          return {
+            input: l.input || "",
+            output: l.result || ""
+          };
+        }
+        return {
+          input: "",
+          output: ""
+        };
+      }
+    }
+  }
+  return {
+    input: "",
+    output: ""
+  };
+}
+const LoaderInternalPropertyName = "__l__";
+const isVue = (compiler) => {
+  const rules = compiler.options.module.rules;
+  const hasVueRule = rules.some((rule) => {
+    if (rule && typeof rule === "object" && rule.test instanceof RegExp && rule.test?.test(".vue")) {
+      return true;
+    }
+    return false;
+  });
+  return hasVueRule;
+};
+export {
+  LoaderInternalPropertyName,
+  findLoaderTotalTiming,
+  getLoaderChartData,
+  getLoaderCosts,
+  getLoaderFileDetails,
+  getLoaderFileFirstInput,
+  getLoaderFileInputAndOutput,
+  getLoaderFileTree,
+  getLoaderFolderStatistics,
+  getLoaderNames,
+  getLoadersCosts,
+  getLoadersTransformData,
+  isVue
+};

package/dist/esm/common/manifest.js

@@ -0,0 +1,46 @@
+import { decompressText } from "./algorithm";
+import { isRemoteUrl } from "./url";
+function isShardingData(data) {
+  if (Array.isArray(data) && data.length > 0) {
+    if (data.every((e) => isRemoteUrl(e))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function fetchShardingData(shardingFiles, fetchImplement) {
+  const res = await Promise.all(
+    shardingFiles.map((url) => fetchImplement(url))
+  );
+  const strings = res.length === 0 ? [] : res.reduce((t, e) => t + e);
+  return typeof strings === "object" ? strings : JSON.parse(decompressText(strings));
+}
+async function fetchShardingFiles(data, fetchImplement, filterKeys) {
+  const datas = await Promise.all(
+    Object.keys(data).map(async (_key) => {
+      const key = _key;
+      const val = data[key];
+      if (filterKeys?.length && filterKeys.indexOf(key) < 0) {
+        return {
+          [key]: []
+        };
+      }
+      if (isShardingData(val)) {
+        return {
+          [key]: await fetchShardingData(val, fetchImplement)
+        };
+      }
+      return {
+        [key]: val
+      };
+    })
+  );
+  return datas.reduce(
+    (t, c) => Object.assign(t, c)
+  );
+}
+export {
+  fetchShardingData,
+  fetchShardingFiles,
+  isShardingData
+};

package/dist/esm/common/package.js

@@ -0,0 +1,71 @@
+import { isEmpty, last, compact } from "lodash";
+const PACKAGE_PREFIX = /(?:node_modules|~)(?:\/\.pnpm)?/;
+const PACKAGE_SLUG = /[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*/;
+const VERSION = /@[\w|\-|_|.]+/;
+const VERSION_NUMBER = "@([\\d.]+)";
+const MODULE_PATH_PACKAGES = new RegExp(
+  [
+    // match dependency directory (eg: `node_modules/`, `node_modules/.pnpm/`)
+    `(?:${PACKAGE_PREFIX.source}/)`,
+    // match package name
+    "(?:",
+    // match `@organization/` or `@organization+`(pnpm)
+    `(?:@${PACKAGE_SLUG.source}[/|+])?`,
+    // match github.com+organization+
+    `(?:${PACKAGE_SLUG.source}\\+)*`,
+    // match package name
+    `(?:${PACKAGE_SLUG.source})`,
+    // match version
+    `(?:${VERSION.source})?`,
+    ")",
+    // Match pnpm peer dependencies (eg: package-a@version_package-b@version)
+    "(?:_",
+    `(?:@${PACKAGE_SLUG.source}[/|+])?`,
+    `(?:${PACKAGE_SLUG.source})`,
+    `(?:@${PACKAGE_SLUG.source})?`,
+    ")*",
+    "/"
+  ].join(""),
+  "g"
+);
+const PACKAGE_PATH_NAME = /(?:(?:node_modules|~)(?:\/\.pnpm)?\/)(?:((?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*[/|+])?(?:(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*\+)*)(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))(?:@[\w|\-|_|.]+)?)(?:_((?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*[/|+])?(?:[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))(?:@[a-zA-Z0-9]+(?:[-|_|.]+[a-zA-Z0-9]+)*))*\//gm;
+const uniqLast = (data) => {
+  const res = [];
+  data.forEach((item, index) => {
+    if (!data.slice(index + 1).includes(item)) {
+      res.push(item);
+    }
+  });
+  return res;
+};
+const getPackageMetaFromModulePath = (modulePath) => {
+  const paths = modulePath.match(MODULE_PATH_PACKAGES);
+  if (!paths) {
+    return { name: "", version: "" };
+  }
+  const names = uniqLast(
+    paths.flatMap((packagePath) => {
+      const found = packagePath.matchAll(PACKAGE_PATH_NAME);
+      if (!found) {
+        return [];
+      }
+      const paksArray = compact([...found].flat());
+      return paksArray.slice(1).filter(Boolean).map((name2) => name2.replace(/\+/g, "/"));
+    })
+  );
+  if (isEmpty(names)) {
+    return { name: "", version: "" };
+  }
+  const name = last(names);
+  const pattern = new RegExp(`(.*)(${last(paths)}).*`);
+  const path = modulePath.replace(pattern, "$1$2").replace(/\/$/, "");
+  return {
+    name,
+    version: path && name ? path.match(new RegExp(`${name}${VERSION_NUMBER}`))?.flat().slice(1)?.[0] || "" : ""
+  };
+};
+export {
+  MODULE_PATH_PACKAGES,
+  PACKAGE_PATH_NAME,
+  getPackageMetaFromModulePath
+};

package/dist/esm/common/plugin.js

@@ -0,0 +1,59 @@
+function getPluginHooks(plugin) {
+  return Object.keys(plugin);
+}
+function getPluginTapNames(plugin) {
+  const hooks = getPluginHooks(plugin);
+  const tapNames = /* @__PURE__ */ new Set();
+  hooks.forEach((hook) => {
+    plugin[hook].forEach((data) => {
+      tapNames.add(data.tapName);
+    });
+  });
+  return [...tapNames];
+}
+function getPluginSummary(plugin) {
+  return {
+    hooks: getPluginHooks(plugin),
+    tapNames: getPluginTapNames(plugin)
+  };
+}
+function getPluginData(plugin, selectedHooks = [], selectedTapNames = []) {
+  const hooks = getPluginHooks(plugin).filter((hook) => {
+    if (selectedHooks.length && selectedHooks.indexOf(hook) === -1) {
+      return false;
+    }
+    return true;
+  });
+  if (!hooks.length)
+    return [];
+  const tapNames = getPluginTapNames(plugin);
+  return tapNames.reduce((total, tapName) => {
+    if (selectedTapNames.length && selectedTapNames.indexOf(tapName) === -1) {
+      return total;
+    }
+    hooks.forEach((hook) => {
+      const hookData = plugin[hook].filter((e) => e.tapName === tapName);
+      if (hookData.length === 0)
+        return;
+      total.push({
+        tapName,
+        hook,
+        data: hookData.map((e) => {
+          return {
+            startAt: e.startAt,
+            endAt: e.endAt,
+            costs: e.costs,
+            type: e.type
+          };
+        })
+      });
+    });
+    return total;
+  }, []);
+}
+export {
+  getPluginData,
+  getPluginHooks,
+  getPluginSummary,
+  getPluginTapNames
+};

package/dist/esm/common/resolver.js

@@ -0,0 +1,54 @@
+import { mergeIntervals } from "./algorithm";
+function isResolveSuccessData(data) {
+  return Boolean(data.result);
+}
+function isResolveFailData(data) {
+  return Boolean(data.error);
+}
+function getResolverCosts(resolver, resolvers) {
+  const blocked = resolvers.filter(
+    (e) => e !== resolver && e.pid === resolver.pid && e.startAt >= resolver.startAt && e.endAt <= resolver.endAt
+  );
+  let costs = resolver.endAt - resolver.startAt;
+  if (blocked.length) {
+    const intervals = blocked.map((e) => [
+      Math.max(e.startAt, resolver.startAt),
+      Math.min(e.endAt, resolver.endAt)
+    ]);
+    mergeIntervals(intervals).forEach((e) => {
+      const sub = e[1] - e[0];
+      costs -= sub;
+    });
+  }
+  return costs;
+}
+function getResolverFileTree(resolver) {
+  return resolver.map((e) => ({ issuerPath: e.issuerPath }));
+}
+function getResolverFileDetails(filepath, resolvers, modules, moduleCodeMap) {
+  const module = modules.find((item) => item.path === filepath);
+  const matchResolvers = resolvers.filter((e) => e.issuerPath === filepath);
+  const before = module && moduleCodeMap && moduleCodeMap[module.id] ? moduleCodeMap[module.id].source : "";
+  const after = matchResolvers.reduce((t, c) => {
+    if (c.request && isResolveSuccessData(c)) {
+      return t.replace(new RegExp(`["']${c.request}["']`), `"${c.result}"`);
+    }
+    return t;
+  }, before);
+  return {
+    filepath,
+    before,
+    after,
+    resolvers: matchResolvers.map((e) => ({
+      ...e,
+      costs: getResolverCosts(e, resolvers)
+    }))
+  };
+}
+export {
+  getResolverCosts,
+  getResolverFileDetails,
+  getResolverFileTree,
+  isResolveFailData,
+  isResolveSuccessData
+};

package/dist/esm/common/rspack.js

@@ -0,0 +1,12 @@
+const RspackLoaderInternalPropertyName = "__l__";
+var RspackSummaryCostsDataName = /* @__PURE__ */ ((RspackSummaryCostsDataName2) => {
+  RspackSummaryCostsDataName2["Bootstrap"] = "bootstrap->rspack:beforeCompile";
+  RspackSummaryCostsDataName2["Compile"] = "rspack:beforeCompile->afterCompile";
+  RspackSummaryCostsDataName2["Done"] = "rspack:afterCompile->done";
+  RspackSummaryCostsDataName2["Minify"] = "rspack:minify(rspack:optimizeChunkAssets)";
+  return RspackSummaryCostsDataName2;
+})(RspackSummaryCostsDataName || {});
+export {
+  RspackLoaderInternalPropertyName,
+  RspackSummaryCostsDataName
+};

package/dist/esm/common/summary.js

@@ -0,0 +1,10 @@
+var SummaryCostsDataName = /* @__PURE__ */ ((SummaryCostsDataName2) => {
+  SummaryCostsDataName2["Bootstrap"] = "bootstrap->beforeCompile";
+  SummaryCostsDataName2["Compile"] = "beforeCompile->afterCompile";
+  SummaryCostsDataName2["Done"] = "afterCompile->done";
+  SummaryCostsDataName2["Minify"] = "minify(webpack4:optimizeChunkAssets|webpack5:processAssets|rspack:processAssets)";
+  return SummaryCostsDataName2;
+})(SummaryCostsDataName || {});
+export {
+  SummaryCostsDataName
+};

package/dist/esm/common/time.js

@@ -0,0 +1,64 @@
+import { hrtime } from "process";
+function toFixedDigits(num, digits = 2) {
+  if (digits === 0) {
+    return Math.floor(num);
+  }
+  return +num.toFixed(digits);
+}
+function getUnit(num, type) {
+  let unit;
+  if (type === "m") {
+    unit = num > 1 ? "mins" : "min";
+  } else {
+    unit = num > 1 ? "hours" : "hour";
+  }
+  return unit;
+}
+function formatCosts(costs) {
+  costs = Number(costs);
+  if (costs >= 1e3) {
+    const sec = costs / 1e3;
+    if (sec >= 60) {
+      let mins = sec / 60;
+      if (mins >= 60) {
+        const hours = toFixedDigits(mins / 60, 0);
+        const restMins = toFixedDigits(mins % 60, 1);
+        const hUnit = getUnit(hours, "h");
+        if (restMins > 0) {
+          return `${hours}${hUnit} ${restMins}${getUnit(restMins, "m")}`;
+        }
+        return `${hours}${hUnit}`;
+      }
+      mins = toFixedDigits(mins, 0);
+      const mUnit = getUnit(mins, "m");
+      const restSec = toFixedDigits(sec % 60, 0);
+      if (restSec > 0) {
+        return `${mins}${mUnit} ${restSec}s`;
+      }
+      return `${mins}${mUnit}`;
+    }
+    return `${toFixedDigits(sec, 1)}s`;
+  }
+  if (costs >= 10) {
+    return `${+toFixedDigits(costs, 0)}ms`;
+  }
+  if (costs >= 1) {
+    return `${+toFixedDigits(costs, 1)}ms`;
+  }
+  let r = +toFixedDigits(costs, 2);
+  if (r === 0) {
+    r = +toFixedDigits(costs, 3);
+  }
+  return `${r}ms`;
+}
+function getCurrentTimestamp(start, startHRTime) {
+  const endHRTime = hrtime(startHRTime);
+  const end = start + endHRTime[0] * 1e3 + (process.env.VITEST ? Math.round(endHRTime[1] / 1e6) : endHRTime[1] / 1e6);
+  return end;
+}
+export {
+  formatCosts,
+  getCurrentTimestamp,
+  getUnit,
+  toFixedDigits
+};

package/dist/esm/common/url.js

@@ -0,0 +1,20 @@
+import { isAbsolute } from "path";
+function isUrl(uri) {
+  return /^https?:\/\//.test(uri);
+}
+function isFilePath(uri) {
+  return isAbsolute(uri);
+}
+function isRemoteUrl(uri) {
+  if (typeof uri === "string") {
+    if (isUrl(uri) || isFilePath(uri)) {
+      return true;
+    }
+  }
+  return false;
+}
+export {
+  isFilePath,
+  isRemoteUrl,
+  isUrl
+};