@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/esm/common/data/index.js

@@ -0,0 +1,265 @@
+import { Rule, SDK } from "@rsdoctor/types";
+import * as Loader from "../loader";
+import * as Resolver from "../resolver";
+import * as Plugin from "../plugin";
+import * as Graph from "../graph";
+import * as Alerts from "../alerts";
+class APIDataLoader {
+  constructor(loader) {
+    this.loader = loader;
+    this.loadAPI = this.loadAPI.bind(this);
+  }
+  log(...args) {
+    console.log(`[${this.constructor.name}]`, ...args);
+  }
+  loadAPI(...args) {
+    const [api, body] = args;
+    switch (api) {
+      case SDK.ServerAPI.API.LoadDataByKey:
+        return this.loader.loadData(
+          body.key
+        );
+      case SDK.ServerAPI.API.GetProjectInfo:
+        return Promise.all([
+          this.loader.loadData("root"),
+          this.loader.loadData("pid"),
+          this.loader.loadData("hash"),
+          this.loader.loadData("summary"),
+          this.loader.loadData("configs"),
+          this.loader.loadData("envinfo"),
+          this.loader.loadData("errors")
+        ]).then(
+          ([root, pid, hash, summary, configs, envinfo, errors]) => ({ root, pid, hash, summary, configs, envinfo, errors })
+        );
+      case SDK.ServerAPI.API.GetClientRoutes:
+        return this.loader.loadManifest().then((res) => {
+          const { enableRoutes = [] } = res.client || {};
+          return enableRoutes;
+        });
+      case SDK.ServerAPI.API.GetLoaderNames:
+        return this.loader.loadData("loader").then((res) => {
+          return Loader.getLoaderNames(res || []);
+        });
+      case SDK.ServerAPI.API.GetLoaderChartData:
+        return this.loader.loadData("loader").then((res) => {
+          return Loader.getLoaderChartData(res || []);
+        });
+      case SDK.ServerAPI.API.GetLoaderFileTree:
+        return this.loader.loadData("loader").then((res) => {
+          return Loader.getLoaderFileTree(res || []);
+        });
+      case SDK.ServerAPI.API.GetLoaderFileDetails:
+        return this.loader.loadData("loader").then((res) => {
+          return Loader.getLoaderFileDetails(
+            body.path,
+            res || []
+          );
+        });
+      case SDK.ServerAPI.API.GetLoaderFolderStatistics:
+        return this.loader.loadData("loader").then((res) => {
+          return Loader.getLoaderFolderStatistics(
+            body.folder,
+            res || []
+          );
+        });
+      case SDK.ServerAPI.API.GetLoaderFileFirstInput:
+        return this.loader.loadData("loader").then((res) => {
+          return Loader.getLoaderFileFirstInput(
+            body.file,
+            res || []
+          );
+        });
+      case SDK.ServerAPI.API.GetLoaderFileInputAndOutput:
+        return this.loader.loadData("loader").then((res) => {
+          return Loader.getLoaderFileFirstInput(
+            body.file,
+            res || []
+          );
+        });
+      case SDK.ServerAPI.API.GetResolverFileTree:
+        return this.loader.loadData("resolver").then((res) => {
+          return Resolver.getResolverFileTree(res || []);
+        });
+      case SDK.ServerAPI.API.GetResolverFileDetails:
+        return Promise.all([
+          this.loader.loadData("resolver"),
+          this.loader.loadData("moduleGraph.modules"),
+          this.loader.loadData("moduleCodeMap")
+        ]).then((res) => {
+          const resolverData = res[0];
+          const modules = res[1];
+          const moduleCodeMap = res[2];
+          return Resolver.getResolverFileDetails(
+            body.filepath,
+            resolverData || [],
+            modules || [],
+            moduleCodeMap || {}
+          );
+        });
+      case SDK.ServerAPI.API.GetPluginSummary:
+        return this.loader.loadData("plugin").then((res) => {
+          return Plugin.getPluginSummary(res || {});
+        });
+      case SDK.ServerAPI.API.GetPluginData:
+        return this.loader.loadData("plugin").then((res) => {
+          const { hooks, tapNames } = body;
+          return Plugin.getPluginData(res || {}, hooks, tapNames);
+        });
+      case SDK.ServerAPI.API.GetAssetsSummary:
+        return this.loader.loadData("chunkGraph").then((res) => {
+          const { withFileContent = true } = body;
+          const { assets = [], chunks = [] } = res || {};
+          return Graph.getAssetsSummary(assets, chunks, {
+            withFileContent
+          });
+        });
+      case SDK.ServerAPI.API.GetAssetDetails:
+        return Promise.all([
+          this.loader.loadData("chunkGraph"),
+          this.loader.loadData("moduleGraph")
+        ]).then((res) => {
+          const { assetPath } = body;
+          const { assets = [], chunks = [] } = res[0] || {};
+          const { modules = [] } = res[1] || {};
+          return Graph.getAssetDetails(assetPath, assets, chunks, modules);
+        });
+      case SDK.ServerAPI.API.GetChunksByModuleId:
+        return Promise.all([
+          this.loader.loadData("chunkGraph"),
+          this.loader.loadData("moduleGraph")
+        ]).then((res) => {
+          const { moduleId } = body;
+          const { chunks = [] } = res[0] || {};
+          const { modules = [] } = res[1] || {};
+          return Graph.getChunksByModuleId(moduleId, modules, chunks);
+        });
+      case SDK.ServerAPI.API.GetModuleDetails:
+        return Promise.all([
+          this.loader.loadData("chunkGraph"),
+          this.loader.loadData("moduleGraph")
+        ]).then((res) => {
+          const { moduleId } = body;
+          const { modules = [], dependencies = [] } = res[1] || {};
+          return Graph.getModuleDetails(moduleId, modules, dependencies);
+        });
+      case SDK.ServerAPI.API.GetModulesByModuleIds:
+        return this.loader.loadData("moduleGraph").then((res) => {
+          const { moduleIds } = body;
+          const { modules = [] } = res || {};
+          return Graph.getModuleIdsByModulesIds(moduleIds, modules);
+        });
+      case SDK.ServerAPI.API.GetEntryPoints:
+        return Promise.all([this.loader.loadData("chunkGraph")]).then((res) => {
+          const [chunkGraph] = res;
+          const { entrypoints = [] } = chunkGraph || {};
+          return Graph.getEntryPoints(entrypoints);
+        });
+      case SDK.ServerAPI.API.GetModuleCodeByModuleId:
+        return this.loader.loadData("moduleCodeMap").then((moduleCodeMap) => {
+          const { moduleId } = body;
+          if (moduleCodeMap) {
+            return moduleCodeMap[moduleId];
+          }
+          return { source: "", transformed: "", parsedSource: "" };
+        });
+      case SDK.ServerAPI.API.GetModuleCodeByModuleIds:
+        return this.loader.loadData("moduleCodeMap").then((moduleCodeMap) => {
+          const { moduleIds } = body;
+          const _moduleCodeData = {};
+          if (moduleCodeMap) {
+            moduleIds.forEach((id) => {
+              _moduleCodeData[id] = moduleCodeMap[id];
+            });
+            return _moduleCodeData;
+          }
+          return [];
+        });
+      case SDK.ServerAPI.API.GetAllModuleGraph:
+        return this.loader.loadData("moduleGraph").then((moduleGraph) => {
+          return moduleGraph?.modules;
+        });
+      case SDK.ServerAPI.API.GetAllChunkGraph:
+        return this.loader.loadData("chunkGraph").then((chunkGraph) => {
+          return chunkGraph?.chunks;
+        });
+      case SDK.ServerAPI.API.GetPackageRelationAlertDetails:
+        return Promise.all([
+          this.loader.loadData("moduleGraph"),
+          this.loader.loadData("errors"),
+          this.loader.loadData("root"),
+          this.loader.loadData("moduleCodeMap")
+        ]).then((res) => {
+          const { id, target } = body;
+          const [moduleGraph, errors = [], root = "", moduleCodeMap] = res;
+          const { modules = [], dependencies = [] } = moduleGraph || {};
+          const { packages = [] } = errors.find((e) => e.id === id) || {};
+          const { dependencies: pkgDependencies = [] } = packages.find(
+            (e) => e.target.name === target.name && e.target.root === target.root && e.target.version === target.version
+          ) || {};
+          return Alerts.getPackageRelationAlertDetails(
+            modules,
+            dependencies,
+            root,
+            pkgDependencies,
+            moduleCodeMap || {}
+          );
+        });
+      case SDK.ServerAPI.API.GetOverlayAlerts:
+        return this.loader.loadData("errors").then((res) => {
+          return (res || []).filter(
+            (e) => e.code === Rule.RuleMessageCodeEnumerated.Overlay
+          );
+        });
+      case SDK.ServerAPI.API.BundleDiffManifest:
+        return this.loader.loadManifest();
+      case SDK.ServerAPI.API.GetBundleDiffSummary:
+        return Promise.all([
+          this.loader.loadManifest(),
+          this.loader.loadData("root"),
+          this.loader.loadData("hash"),
+          this.loader.loadData("errors"),
+          this.loader.loadData("chunkGraph"),
+          this.loader.loadData("moduleGraph"),
+          this.loader.loadData("moduleCodeMap"),
+          this.loader.loadData("packageGraph"),
+          this.loader.loadData("configs")
+        ]).then(
+          ([
+            _manifest,
+            root = "",
+            hash = "",
+            errors = {},
+            chunkGraph = {},
+            moduleGraph = {},
+            moduleCodeMap = {},
+            packageGraph = {},
+            configs = []
+          ]) => {
+            let outputFilename = "";
+            if (typeof configs[0]?.config?.output?.chunkFilename === "string") {
+              outputFilename = configs[0]?.config.output.chunkFilename;
+            }
+            return {
+              root,
+              hash,
+              errors,
+              chunkGraph,
+              moduleGraph,
+              packageGraph,
+              outputFilename,
+              moduleCodeMap
+            };
+          }
+        );
+      case SDK.ServerAPI.API.GetTileReportHtml:
+        return this.loader.loadData("otherReports").then((otherReports) => {
+          return otherReports?.tileReportHtml;
+        });
+      default:
+        throw new Error(`API not implement: "${api}"`);
+    }
+  }
+}
+export {
+  APIDataLoader
+};

package/dist/esm/common/graph/assets.js

@@ -0,0 +1,286 @@
+import { Client, Constants } from "@rsdoctor/types";
+import { getChunksByAsset } from "./chunk";
+import { getModulesByAsset } from "./modules";
+const EXT = "js|css|html";
+const hashPattern = /[a-z|A-Z|0-9]{4,32}/;
+const hashSeparatorPattern = /[-|.]/;
+const fileExtensionPattern = /(?:\.[a-z｜A-Z|0-9]{2,}){1,}/;
+const filenamePattern = new RegExp(
+  `(.*)${hashSeparatorPattern.source}${hashPattern.source}(${fileExtensionPattern.source})$`
+);
+function formatAssetName(assetName, fileConfig) {
+  const splitFilesList = fileConfig?.split(".");
+  let outputFileTailName = "";
+  let unHashedFileName = assetName;
+  if (splitFilesList?.length && splitFilesList.length >= 3 && splitFilesList[splitFilesList.length - 2]?.indexOf("[") < 0 && EXT.indexOf(splitFilesList[splitFilesList.length - 1]) > -1) {
+    outputFileTailName = splitFilesList[splitFilesList.length - 2];
+    const _regPattern = /(.*)(\.[a-f0-9]{4,32})([^.]*.[^.]+){2,}/g;
+    unHashedFileName = assetName.replace(_regPattern, "$1");
+    return `${unHashedFileName}.${outputFileTailName}.${assetName.substring(
+      assetName.lastIndexOf(".") + 1
+    )}`;
+  }
+  return assetName.replace(filenamePattern, "$1$2");
+}
+function isAssetMatchExtension(asset, ext) {
+  return asset.path.slice(-ext.length) === ext;
+}
+function isAssetMatchExtensions(asset, exts) {
+  if (!exts.length)
+    return false;
+  return exts.some((ext) => isAssetMatchExtension(asset, ext));
+}
+function filterAssetsByExtensions(assets, exts) {
+  if (typeof exts === "string")
+    return assets.filter((e) => isAssetMatchExtension(e, exts));
+  if (Array.isArray(exts)) {
+    return assets.filter((e) => isAssetMatchExtensions(e, exts));
+  }
+  return [];
+}
+function filterAssets(assets, filterOrExtensions) {
+  if (filterOrExtensions) {
+    if (typeof filterOrExtensions === "function") {
+      assets = assets.filter(filterOrExtensions);
+    } else {
+      assets = filterAssetsByExtensions(assets, filterOrExtensions);
+    }
+  }
+  return assets;
+}
+function getAssetsSizeInfo(assets, chunks, options = {}) {
+  const { withFileContent = true, filterOrExtensions } = options;
+  assets = assets.filter(
+    (e) => !isAssetMatchExtensions(e, Constants.MapExtensions)
+  );
+  if (filterOrExtensions) {
+    assets = filterAssets(assets, filterOrExtensions);
+  }
+  if (assets.length) {
+    return {
+      count: assets.length,
+      size: assets.reduce((t, c) => t + c.size, 0),
+      files: assets.map((e) => ({
+        path: e.path,
+        size: e.size,
+        initial: isInitialAsset(e, chunks),
+        content: withFileContent ? e.content : void 0
+      }))
+    };
+  }
+  return {
+    count: 0,
+    size: 0,
+    files: []
+  };
+}
+function isInitialAsset(asset, chunks) {
+  const cks = getChunksByAsset(asset, chunks);
+  return cks.some((e) => Boolean(e.initial));
+}
+function getInitialAssetsSizeInfo(assets, chunks, options = {}) {
+  if (options.filterOrExtensions) {
+    assets = filterAssets(assets, options.filterOrExtensions);
+  }
+  return getAssetsSizeInfo(assets, chunks, {
+    ...options,
+    filterOrExtensions: (asset) => isInitialAsset(asset, chunks)
+  });
+}
+function getAssetsDiffResult(baseline, current) {
+  return {
+    all: {
+      total: diffAssetsByExtensions(baseline, current)
+    },
+    js: {
+      total: diffAssetsByExtensions(baseline, current, Constants.JSExtension),
+      initial: diffAssetsByExtensions(
+        baseline,
+        current,
+        Constants.JSExtension,
+        true
+      )
+    },
+    css: {
+      total: diffAssetsByExtensions(baseline, current, Constants.CSSExtension),
+      initial: diffAssetsByExtensions(
+        baseline,
+        current,
+        Constants.CSSExtension,
+        true
+      )
+    },
+    imgs: {
+      total: diffAssetsByExtensions(baseline, current, Constants.ImgExtensions)
+    },
+    html: {
+      total: diffAssetsByExtensions(baseline, current, Constants.HtmlExtension)
+    },
+    media: {
+      total: diffAssetsByExtensions(
+        baseline,
+        current,
+        Constants.MediaExtensions
+      )
+    },
+    fonts: {
+      total: diffAssetsByExtensions(
+        baseline,
+        current,
+        Constants.FontExtensions
+      )
+    },
+    others: {
+      total: diffAssetsByExtensions(
+        baseline,
+        current,
+        (asset) => !isAssetMatchExtensions(
+          asset,
+          [
+            Constants.JSExtension,
+            Constants.CSSExtension,
+            Constants.HtmlExtension
+          ].concat(
+            Constants.ImgExtensions,
+            Constants.MediaExtensions,
+            Constants.FontExtensions,
+            Constants.MapExtensions
+          )
+        )
+      )
+    }
+  };
+}
+function diffSize(bSize, cSize) {
+  const isEqual = bSize === cSize;
+  const percent = isEqual ? 0 : bSize === 0 ? 100 : Math.abs(cSize - bSize) / bSize * 100;
+  const state = isEqual ? Client.RsdoctorClientDiffState.Equal : bSize > cSize ? Client.RsdoctorClientDiffState.Down : Client.RsdoctorClientDiffState.Up;
+  return { percent, state };
+}
+function diffAssetsByExtensions(baseline, current, filterOrExtensions, isInitial = false) {
+  const { size: bSize, count: bCount } = isInitial ? getInitialAssetsSizeInfo(baseline.assets, baseline.chunks, {
+    filterOrExtensions
+  }) : getAssetsSizeInfo(baseline.assets, baseline.chunks, {
+    filterOrExtensions
+  });
+  let cSize;
+  let cCount;
+  if (baseline === current) {
+    cSize = bSize;
+    cCount = bCount;
+  } else {
+    const { size, count } = isInitial ? getInitialAssetsSizeInfo(current.assets, current.chunks, {
+      filterOrExtensions
+    }) : getAssetsSizeInfo(current.assets, current.chunks, {
+      filterOrExtensions
+    });
+    cSize = size;
+    cCount = count;
+  }
+  const { percent, state } = diffSize(bSize, cSize);
+  return {
+    size: {
+      baseline: bSize,
+      current: cSize
+    },
+    count: {
+      baseline: bCount,
+      current: cCount
+    },
+    percent,
+    state
+  };
+}
+function getAssetsSummary(assets, chunks, options = {}) {
+  const jsOpt = {
+    ...options,
+    filterOrExtensions: Constants.JSExtension
+  };
+  const cssOpt = {
+    ...options,
+    filterOrExtensions: Constants.CSSExtension
+  };
+  const imgOpt = {
+    ...options,
+    filterOrExtensions: Constants.ImgExtensions
+  };
+  const htmlOpt = {
+    ...options,
+    filterOrExtensions: Constants.HtmlExtension
+  };
+  const mediaOpt = {
+    ...options,
+    filterOrExtensions: Constants.MediaExtensions
+  };
+  const fontOpt = {
+    ...options,
+    filterOrExtensions: Constants.FontExtensions
+  };
+  const otherOpt = {
+    ...options,
+    filterOrExtensions: (asset) => !isAssetMatchExtensions(
+      asset,
+      [
+        Constants.JSExtension,
+        Constants.CSSExtension,
+        Constants.HtmlExtension
+      ].concat(
+        Constants.ImgExtensions,
+        Constants.MediaExtensions,
+        Constants.FontExtensions,
+        Constants.MapExtensions
+      )
+    )
+  };
+  return {
+    all: {
+      total: getAssetsSizeInfo(assets, chunks, options)
+    },
+    js: {
+      total: getAssetsSizeInfo(assets, chunks, jsOpt),
+      initial: getInitialAssetsSizeInfo(assets, chunks, jsOpt)
+    },
+    css: {
+      total: getAssetsSizeInfo(assets, chunks, cssOpt),
+      initial: getInitialAssetsSizeInfo(assets, chunks, cssOpt)
+    },
+    imgs: {
+      total: getAssetsSizeInfo(assets, chunks, imgOpt)
+    },
+    html: {
+      total: getAssetsSizeInfo(assets, chunks, htmlOpt)
+    },
+    media: {
+      total: getAssetsSizeInfo(assets, chunks, mediaOpt)
+    },
+    fonts: {
+      total: getAssetsSizeInfo(assets, chunks, fontOpt)
+    },
+    others: {
+      total: getAssetsSizeInfo(assets, chunks, otherOpt)
+    }
+  };
+}
+function getAssetDetails(assetPath, assets, chunks, modules) {
+  const asset = assets.find((e) => e.path === assetPath);
+  return {
+    asset,
+    chunks: getChunksByAsset(asset, chunks),
+    modules: getModulesByAsset(asset, chunks, modules)
+  };
+}
+export {
+  diffAssetsByExtensions,
+  diffSize,
+  filterAssets,
+  filterAssetsByExtensions,
+  formatAssetName,
+  getAssetDetails,
+  getAssetsDiffResult,
+  getAssetsSizeInfo,
+  getAssetsSummary,
+  getInitialAssetsSizeInfo,
+  isAssetMatchExtension,
+  isAssetMatchExtensions,
+  isInitialAsset
+};

package/dist/esm/common/graph/chunk.js

@@ -0,0 +1,38 @@
+function getChunkIdsByAsset(asset) {
+  if (asset.chunks) {
+    return asset.chunks;
+  }
+  return [];
+}
+function getChunksByModule(module, chunks) {
+  if (module.chunks.length) {
+    return getChunksByChunkIds(module.chunks, chunks);
+  }
+  return [];
+}
+function getChunkByChunkId(chunkId, chunks) {
+  return chunks.find((e) => e.id === chunkId);
+}
+function getChunksByChunkIds(chunkIds, chunks) {
+  if (chunkIds.length) {
+    return chunkIds.map((id) => getChunkByChunkId(id, chunks)).filter(Boolean);
+  }
+  return [];
+}
+function getChunksByAsset(asset, chunks) {
+  return getChunksByChunkIds(getChunkIdsByAsset(asset), chunks);
+}
+function getChunksByModuleId(id, modules, chunks) {
+  const mod = modules.find((e) => e.id === id);
+  if (!mod)
+    return [];
+  return getChunksByModule(mod, chunks);
+}
+export {
+  getChunkByChunkId,
+  getChunkIdsByAsset,
+  getChunksByAsset,
+  getChunksByChunkIds,
+  getChunksByModule,
+  getChunksByModuleId
+};

package/dist/esm/common/graph/dependency.js

@@ -0,0 +1,14 @@
+function getDependencyByPackageData(dep, dependencies) {
+  return dependencies.find((item) => item.id === dep.dependencyId);
+}
+function getDependenciesByModule(module, dependencies) {
+  return module.dependencies.map((id) => dependencies.find((dep) => dep.id === id)).filter(Boolean);
+}
+function getDependencyByResolvedRequest(resolvedRequest, dependencies) {
+  return dependencies.find((e) => e.resolvedRequest === resolvedRequest);
+}
+export {
+  getDependenciesByModule,
+  getDependencyByPackageData,
+  getDependencyByResolvedRequest
+};

package/dist/esm/common/graph/entrypoints.js

@@ -0,0 +1,6 @@
+function getEntryPoints(entrypoints) {
+  return entrypoints;
+}
+export {
+  getEntryPoints
+};

package/dist/esm/common/graph/index.js

@@ -0,0 +1,5 @@
+export * from "./assets";
+export * from "./chunk";
+export * from "./modules";
+export * from "./dependency";
+export * from "./entrypoints";

package/dist/esm/common/graph/modules.js

@@ -0,0 +1,70 @@
+import { getChunksByChunkIds, getChunkIdsByAsset } from "./chunk";
+import {
+  getDependenciesByModule,
+  getDependencyByPackageData
+} from "./dependency";
+function getModulesByAsset(asset, chunks, modules) {
+  const ids = getChunkIdsByAsset(asset);
+  const cks = getChunksByChunkIds(ids, chunks);
+  const res = getModulesByChunks(cks, modules);
+  return res;
+}
+function getModuleIdsByChunk(chunk) {
+  const { modules = [] } = chunk;
+  return modules;
+}
+function getModuleIdsByModulesIds(moduleIds, modules) {
+  return moduleIds.map((id) => modules.find((m) => m.id === id)).filter(Boolean);
+}
+function getModulesByChunk(chunk, modules) {
+  const ids = getModuleIdsByChunk(chunk);
+  return ids.map((id) => modules.find((e) => e.id === id)).filter(Boolean);
+}
+function getModulesByChunks(chunks, modules) {
+  const res = [];
+  chunks.forEach((chunk) => {
+    getModulesByChunk(chunk, modules).forEach((md) => {
+      if (!res.filter((_m) => _m.id === md.id).length)
+        res.push(md);
+    });
+  });
+  return res;
+}
+function getModuleByDependency(dep, modules) {
+  return modules.find((item) => item.id === dep.module);
+}
+function filterModulesAndDependenciesByPackageDeps(deps, dependencies, modules) {
+  const _dependencies = [];
+  const _modules = [];
+  for (let i = 0; i < deps.length; i++) {
+    const dep = getDependencyByPackageData(deps[i], dependencies);
+    if (dep) {
+      _dependencies.push(dep);
+      const module = getModuleByDependency(dep, modules);
+      if (module) {
+        _modules.push(module);
+      }
+    }
+  }
+  return {
+    dependencies: _dependencies,
+    modules: _modules
+  };
+}
+function getModuleDetails(moduleId, modules, dependencies) {
+  const module = modules.find((e) => e.id === moduleId);
+  return {
+    module,
+    dependencies: getDependenciesByModule(module, dependencies)
+  };
+}
+export {
+  filterModulesAndDependenciesByPackageDeps,
+  getModuleByDependency,
+  getModuleDetails,
+  getModuleIdsByChunk,
+  getModuleIdsByModulesIds,
+  getModulesByAsset,
+  getModulesByChunk,
+  getModulesByChunks
+};