@rsdoctor/utils 1.1.10 → 1.2.0-beta.1

package/dist/esm/common/loader.js

@@ -1,279 +0,0 @@
-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.includes("builtin")) {
-      return false;
-    }
-    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(getLoadrName(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({
-        layer: item.resource.layer,
-        loader: getLoadrName(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,
-      layer: resource.layer,
-      loaders: arr.map((l) => {
-        return {
-          key: l.path,
-          loader: getLoadrName(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,
-        loader: getLoadrName(el.loader),
-        costs: getLoaderCosts(el, list)
-      };
-    })
-  };
-}
-function getLoaderFolderStatistics(folder, loaders) {
-  const datas = loaders.filter((data) => {
-    const { path } = data.resource;
-    return path.startsWith(folder);
-  });
-  const filteredLoaders = [];
-  const uniqueLoaders = /* @__PURE__ */ new Map();
-  datas.forEach((data) => {
-    data.loaders.forEach((fl) => {
-      const uniqueLoader = uniqueLoaders.get(fl.loader);
-      if (uniqueLoader) {
-        uniqueLoaders.set(fl.loader, {
-          files: uniqueLoader.files + 1,
-          path: fl.path
-        });
-      } else {
-        uniqueLoaders.set(fl.loader, { files: 1, path: fl.path });
-      }
-      return filteredLoaders.push({
-        loader: fl.loader,
-        startAt: fl.startAt,
-        endAt: fl.endAt,
-        pid: fl.pid
-      });
-    });
-  });
-  const loaderCosts = Array.from(uniqueLoaders).map((uniqueLoader) => {
-    const filter = (l) => l.loader === uniqueLoader[0];
-    const costs = getLoadersCosts(filter, filteredLoaders);
-    return {
-      loader: uniqueLoader[0],
-      files: uniqueLoader[1].files,
-      path: uniqueLoader[1].path,
-      costs
-    };
-  });
-  return loaderCosts;
-}
-function collectResourceDirectories(loaders, root) {
-  const directories = /* @__PURE__ */ new Set();
-  loaders.forEach((item) => {
-    if (item.resource.path.startsWith(root)) {
-      const pathParts = item.resource.path.split(root).slice(1).join("/").split("/");
-      if (pathParts.length >= 2) {
-        const twoLevelDir = pathParts.slice(0, 2).join("/");
-        directories.add(`${root}/${twoLevelDir}`);
-      }
-    } else {
-      const pathParts = item.resource.path.split("/");
-      const twoLevelDir = pathParts.slice(0, pathParts.length - 1).join("/");
-      directories.add(twoLevelDir);
-    }
-  });
-  return Array.from(directories);
-}
-function getDirectoriesLoaders(loaders, root) {
-  const rootPath = root || process.cwd();
-  const directories = collectResourceDirectories(loaders, rootPath);
-  return directories.map((directory) => {
-    const stats = getLoaderFolderStatistics(directory, loaders);
-    return {
-      directory,
-      stats
-    };
-  });
-}
-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 = "module" in compiler.options && 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;
-};
-const getLoadrName = (loader) => {
-  const regResults = loader.includes("node_modules") ? loader.split("node_modules") : null;
-  return regResults ? regResults[regResults.length - 1] : loader;
-};
-export {
-  LoaderInternalPropertyName,
-  findLoaderTotalTiming,
-  getDirectoriesLoaders,
-  getLoaderChartData,
-  getLoaderCosts,
-  getLoaderFileDetails,
-  getLoaderFileFirstInput,
-  getLoaderFileInputAndOutput,
-  getLoaderFileTree,
-  getLoaderFolderStatistics,
-  getLoaderNames,
-  getLoadersCosts,
-  getLoadersTransformData,
-  isVue
-};

package/dist/esm/common/lodash.js

@@ -1,49 +0,0 @@
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-function isNumber(value) {
-  return typeof value === "number" && !Number.isNaN(value);
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function isEmpty(value) {
-  return value == null || // Check for null or undefined
-  Array.isArray(value) && value.length === 0 || // Check for empty array
-  typeof value === "object" && Object.keys(value).length === 0;
-}
-function last(array) {
-  return array[array.length - 1];
-}
-function compact(array) {
-  return array.filter((item) => item != null || !item);
-}
-function isNil(value) {
-  return value === null || value === void 0;
-}
-const isPlainObject = (obj) => {
-  return obj !== null && typeof obj === "object" && Object.getPrototypeOf(obj) === Object.prototype;
-};
-const isString = (v) => typeof v === "string" || !!v && typeof v === "object" && !Array.isArray(v) && {}.toString.call(v) === "[object String]";
-function pick(obj, keys) {
-  const result = {};
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (Object.hasOwn(obj, key)) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-export {
-  compact,
-  isEmpty,
-  isNil,
-  isNumber,
-  isObject,
-  isPlainObject,
-  isString,
-  isUndefined,
-  last,
-  pick
-};

package/dist/esm/common/manifest.js

@@ -1,46 +0,0 @@
-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

@@ -1,71 +0,0 @@
-import { compact, isEmpty, last } 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

@@ -1,59 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

package/dist/esm/common/time.js

@@ -1,64 +0,0 @@
-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

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