@rsdoctor/components 0.0.2-beta.0

package/dist/utils/file.js

@@ -0,0 +1,154 @@
+import { get, startsWith } from "lodash-es";
+import { message } from "antd";
+const rootDirname = (file, sep = "/") => {
+  const idx = file == null ? void 0 : file.indexOf(sep);
+  if (idx === -1) {
+    return null;
+  }
+  if (idx === 0) {
+    return sep + (rootDirname(file == null ? void 0 : file.slice(1)) || "");
+  }
+  return file == null ? void 0 : file.slice(0, idx);
+};
+function mapFileKey(arr, depth = 2, filter = () => true) {
+  let d = 0;
+  const res = [];
+  let parent = arr;
+  while (d < depth) {
+    parent.filter(filter).forEach((e) => {
+      if (!e.isLeaf) {
+        res.push(e.key);
+      }
+    });
+    parent = parent.reduce((t, e) => t.concat(e.children || []), []);
+    if (!parent.length)
+      break;
+    d++;
+  }
+  return res;
+}
+const basenameKey = "__BASENAME__";
+function flattenDirectory(n, parent, sep = "/", inlinedResourcePathKey, dirTitle = (_dir, defaultTitle) => defaultTitle) {
+  if (n.isLeaf)
+    return;
+  if (parent.children && parent.children.length === 1) {
+    const defaultTitle = [parent[basenameKey], n[basenameKey]].join(sep);
+    parent[inlinedResourcePathKey] = n[inlinedResourcePathKey];
+    parent[basenameKey] = defaultTitle;
+    parent.key = [parent.key, n.key].join("-");
+    parent.children = n.children;
+    parent.title = dirTitle(parent, defaultTitle);
+    n.children && n.children.forEach((c) => {
+      flattenDirectory(c, parent, sep, inlinedResourcePathKey, dirTitle);
+    });
+  } else {
+    n.title = dirTitle(n, n[basenameKey]);
+    n.children && n.children.forEach((c) => {
+      flattenDirectory(c, n, sep, inlinedResourcePathKey, dirTitle);
+    });
+  }
+}
+function createFileStructures({
+  files,
+  sep = "/",
+  inlinedResourcePathKey = "__RESOURCEPATH__",
+  fileTitle = (_file, basename) => basename,
+  dirTitle = (_dir, defaultTitle) => defaultTitle
+}) {
+  const sepRegexp = new RegExp(sep);
+  const res = files.reduce(
+    (t, file) => {
+      let dir = rootDirname(file, sep);
+      let basename = dir ? file == null ? void 0 : file.slice(dir.length + 1) : file;
+      let parent = t;
+      while (dir) {
+        let exist = parent.children.find((e) => e.title === dir);
+        if (!exist) {
+          const p = [parent[inlinedResourcePathKey], dir].filter(Boolean).join(sep);
+          exist = {
+            title: dir,
+            // key: [parent.key, parent.children!.length].join('-'),
+            key: p,
+            children: [],
+            [inlinedResourcePathKey]: p,
+            [basenameKey]: dir
+          };
+          parent.children.push(exist);
+        }
+        parent = exist;
+        dir = rootDirname(basename);
+        basename = dir ? basename.slice(dir.length).replace(sepRegexp, "") : basename;
+      }
+      if (parent.children.some((e) => get(e, inlinedResourcePathKey) === file))
+        return t;
+      parent.children.push({
+        title() {
+          return fileTitle(file, basename);
+        },
+        // key: [parent.key, parent.children!.length].join('-'),
+        key: file,
+        isLeaf: true,
+        [inlinedResourcePathKey]: file,
+        [basenameKey]: basename
+      });
+      return t;
+    },
+    { key: "0", children: [] }
+  ).children;
+  res.forEach((e) => {
+    e.children && e.children.forEach((item) => flattenDirectory(item, e, sep, inlinedResourcePathKey, dirTitle));
+  });
+  return res;
+}
+function beautifyPath(path, cwd) {
+  if (startsWith(path, cwd)) {
+    return path.replace(cwd, ".");
+  }
+  return path;
+}
+function readJSONByFileReader(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const { result } = reader;
+      console.log("reader result: ", result);
+      try {
+        const json = JSON.parse(result.toString());
+        resolve(json);
+      } catch (err) {
+        message.error("json parse error");
+        reject(err);
+      }
+    };
+    reader.onerror = () => {
+      const msg = "upload json file error, please try again.";
+      message.error(msg);
+      reject(new Error(msg));
+    };
+    reader.readAsText(file.originFileObj || file);
+  });
+}
+function beautifyModulePath(modulePath, cwd) {
+  const res = beautifyPath(modulePath, cwd);
+  const str = "/node_modules/";
+  const idx = res.lastIndexOf(str);
+  if (idx > -1) {
+    return {
+      alias: res.slice(idx + str.length),
+      inNodeModules: true
+    };
+  }
+  return {
+    alias: res,
+    inNodeModules: false
+  };
+}
+export {
+  beautifyModulePath,
+  beautifyPath,
+  createFileStructures,
+  flattenDirectory,
+  mapFileKey,
+  readJSONByFileReader,
+  rootDirname
+};

package/dist/utils/hooks.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { Manifest, Rule, SDK } from '@rsdoctor/types';
+import { useTranslation } from 'react-i18next';
+import './i18n';
+export declare const useI18n: typeof useTranslation;
+export declare function useRuleIndexNavigate(code: string, link?: string | undefined): () => void;
+export declare function useUrlQuery(): Record<string, string | undefined>;
+export declare function useLoading(defaultLoading?: boolean): {
+  loading: boolean;
+  setLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+  withLoading(func: (...args: unknown[]) => Promise<unknown> | unknown): Promise<void>;
+};
+export declare function useProjectRootByManifest(manifest: Manifest.DoctorManifest): string;
+export declare function useHashByManifest(manifest: Manifest.DoctorManifest): string;
+export declare function useCloudManifestUrlByManifest(manifest: Manifest.DoctorManifest | Manifest.DoctorManifestWithShardingFiles | void): void;
+export declare function useChunkGraphByManifest(manifest: Manifest.DoctorManifest): SDK.ChunkGraphData;
+export declare function useConfigOutputFileNameByManifest(manifest: Manifest.DoctorManifest): string;
+export declare function useModuleGraphByManifest(manifest: Manifest.DoctorManifest): SDK.ModuleGraphData;
+export declare function useModuleGraph(moduleGraph: SDK.ModuleGraphData): SDK.ModuleGraphData;
+export declare function usePackageGraphByManifest(manifest: Manifest.DoctorManifest): SDK.PackageGraphData;
+export declare function useUniqModulesByManifest(manifest: Manifest.DoctorManifest): SDK.ModuleData[];
+export declare function useUniqModules(modules: SDK.ModuleData[]): SDK.ModuleData[];
+export declare function useErrorsByManifest(manifest: Manifest.DoctorManifest): Rule.RuleStoreData;
+export declare function useBundleAlertsByManifest(manifest: Manifest.DoctorManifest): Rule.RuleStoreDataItem[];
+export declare function useDuplicatePackagesByManifest(manifest: Manifest.DoctorManifest): Rule.PackageRelationDiffRuleStoreData[];
+export declare function useCompileAlertsByErrors(errors: Manifest.DoctorManifestData['errors']): Rule.RuleStoreDataItem[];
+export declare function useBundleAlertsByErrors(errors: Manifest.DoctorManifestData['errors']): Rule.RuleStoreDataItem[];
+export declare function useDuplicatePackagesByErrors(errors: Manifest.DoctorManifestData['errors']): Rule.PackageRelationDiffRuleStoreData[];
+export declare function useWebpackConfigurationByConfigs(configs?: SDK.ConfigData): SDK.WebpackConfigData | null | undefined;
+export declare function useDetectIfCloudIdeEnv(): boolean;

package/dist/utils/hooks.js

@@ -0,0 +1,256 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { Algorithm } from "@rsdoctor/utils/common";
+import { Client, Rule } from "@rsdoctor/types";
+import { uniqBy, isArray, defaults } from "lodash-es";
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { useNavigate, useLocation } from "react-router-dom";
+import parse from "url-parse";
+import "./i18n";
+import { setLocaleToStorage } from "./storage";
+const route = Client.DoctorClientRoutes.RuleIndex;
+const useI18n = () => {
+  const _a = useTranslation(), { i18n } = _a, rest = __objRest(_a, ["i18n"]);
+  return __spreadProps(__spreadValues({}, rest), {
+    i18n: __spreadProps(__spreadValues({}, i18n), {
+      changeLanguage(lng, callback) {
+        return i18n.changeLanguage(lng, (error, t) => {
+          if (!error) {
+            setLocaleToStorage(lng);
+          }
+          callback && callback(error, t);
+        });
+      }
+    })
+  });
+};
+function useRuleIndexNavigate(code, link) {
+  const navigate = useNavigate();
+  if (link) {
+    return () => window.open(link, "__blank");
+  }
+  return () => {
+    navigate(`${route}?${Rule.DoctorRuleClientConstant.UrlQueryForErrorCode}=${code}`);
+  };
+}
+function useUrlQuery() {
+  const search = useLocation().search || location.search;
+  const { query } = parse(search, true);
+  return query;
+}
+function useLoading(defaultLoading = false) {
+  const [loading, setLoading] = useState(defaultLoading);
+  return {
+    loading,
+    setLoading,
+    withLoading(func) {
+      return __async(this, null, function* () {
+        try {
+          setLoading(true);
+          yield func();
+        } finally {
+          setLoading(false);
+        }
+      });
+    }
+  };
+}
+function useProjectRootByManifest(manifest) {
+  return manifest.data.root;
+}
+function useHashByManifest(manifest) {
+  return manifest.data.hash;
+}
+function useCloudManifestUrlByManifest(manifest) {
+  if (!manifest)
+    return;
+}
+function ensurePlainObject(value, dfts) {
+  if (value && typeof value === "object") {
+    if (isArray(value)) {
+      return dfts;
+    }
+    return defaults(value, dfts);
+  }
+  return dfts;
+}
+function useChunkGraphByManifest(manifest) {
+  const prev = manifest.data.chunkGraph;
+  if (typeof prev === "string") {
+    manifest.data.chunkGraph = JSON.parse(Algorithm.decompressText(prev));
+  }
+  return ensurePlainObject(manifest.data.chunkGraph, { assets: [], chunks: [], entrypoints: [] });
+}
+function useConfigOutputFileNameByManifest(manifest) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (typeof ((_d = (_c = (_b = (_a = manifest.data.configs) == null ? void 0 : _a[0]) == null ? void 0 : _b.config) == null ? void 0 : _c.output) == null ? void 0 : _d.filename) === "string") {
+    return (_h = (_g = (_f = (_e = manifest.data.configs) == null ? void 0 : _e[0]) == null ? void 0 : _f.config) == null ? void 0 : _g.output) == null ? void 0 : _h.filename;
+  }
+  return "";
+}
+function useModuleGraphByManifest(manifest) {
+  const prev = manifest.data.moduleGraph;
+  if (typeof prev === "string") {
+    manifest.data.moduleGraph = JSON.parse(Algorithm.decompressText(prev));
+  }
+  return ensurePlainObject(manifest.data.moduleGraph, {
+    dependencies: [],
+    modules: [],
+    moduleGraphModules: [],
+    exports: [],
+    sideEffects: [],
+    variables: []
+  });
+}
+function useModuleGraph(moduleGraph) {
+  const prev = moduleGraph;
+  if (typeof prev === "string") {
+    moduleGraph = JSON.parse(Algorithm.decompressText(prev));
+  }
+  return ensurePlainObject(moduleGraph, {
+    dependencies: [],
+    modules: [],
+    moduleGraphModules: [],
+    exports: [],
+    sideEffects: [],
+    variables: []
+  });
+}
+function usePackageGraphByManifest(manifest) {
+  const prev = manifest.data.packageGraph;
+  if (typeof prev === "string") {
+    manifest.data.packageGraph = JSON.parse(Algorithm.decompressText(prev));
+  }
+  return ensurePlainObject(manifest.data.packageGraph, {
+    packages: [],
+    dependencies: []
+  });
+}
+function useUniqModulesByManifest(manifest) {
+  return uniqBy(useModuleGraphByManifest(manifest).modules, (e) => e.path);
+}
+function useUniqModules(modules) {
+  return uniqBy(modules, (e) => e.path);
+}
+function useErrorsByManifest(manifest) {
+  const prev = manifest.data.errors;
+  if (typeof prev === "string") {
+    manifest.data.errors = JSON.parse(Algorithm.decompressText(prev));
+  }
+  return manifest.data.errors || [];
+}
+function useBundleAlertsByManifest(manifest) {
+  const errors = useErrorsByManifest(manifest);
+  return useBundleAlertsByErrors(errors);
+}
+function useDuplicatePackagesByManifest(manifest) {
+  const alerts = useBundleAlertsByManifest(manifest);
+  return useDuplicatePackagesByErrors(alerts);
+}
+function useCompileAlertsByErrors(errors) {
+  if (isArray(errors)) {
+    return errors.filter(
+      (e) => e.category === Rule.RuleMessageCategory.Compile && e.code !== Rule.RuleMessageCodeEnumerated.Overlay
+    );
+  }
+  return [];
+}
+function useBundleAlertsByErrors(errors) {
+  if (isArray(errors)) {
+    return errors.filter(
+      (e) => e.category === Rule.RuleMessageCategory.Bundle && e.code !== Rule.RuleMessageCodeEnumerated.Overlay
+    );
+  }
+  return [];
+}
+function useDuplicatePackagesByErrors(errors) {
+  return useBundleAlertsByErrors(errors).filter(
+    (e) => e.code === Rule.RuleErrorMap.E1001.code
+  );
+}
+function useWebpackConfigurationByConfigs(configs = []) {
+  if (isArray(configs)) {
+    return configs.find((e) => e.name === "webpack");
+  }
+  return null;
+}
+function useDetectIfCloudIdeEnv() {
+  if (window.location.protocol === "https:" && window.location.href.indexOf("ide-proxy") > 0) {
+    return true;
+  }
+  return false;
+}
+export {
+  useBundleAlertsByErrors,
+  useBundleAlertsByManifest,
+  useChunkGraphByManifest,
+  useCloudManifestUrlByManifest,
+  useCompileAlertsByErrors,
+  useConfigOutputFileNameByManifest,
+  useDetectIfCloudIdeEnv,
+  useDuplicatePackagesByErrors,
+  useDuplicatePackagesByManifest,
+  useErrorsByManifest,
+  useHashByManifest,
+  useI18n,
+  useLoading,
+  useModuleGraph,
+  useModuleGraphByManifest,
+  usePackageGraphByManifest,
+  useProjectRootByManifest,
+  useRuleIndexNavigate,
+  useUniqModules,
+  useUniqModulesByManifest,
+  useUrlQuery,
+  useWebpackConfigurationByConfigs
+};

package/dist/utils/i18n/cn.d.ts

@@ -0,0 +1,3 @@
+import en from './en';
+declare const cn: typeof en;
+export default cn;

package/dist/utils/i18n/cn.js

@@ -0,0 +1,33 @@
+const cn = {
+  Overall: "概览",
+  "Compile Analysis": "编译分析",
+  LoadersAnalysis: "Loaders 分析",
+  "Loaders Overall": "Loaders 概览",
+  "Loaders Analysis": "Loaders 分析",
+  PluginsAnalysis: "Plugins 分析",
+  ModuleResolve: "Module Resolve 分析",
+  "Bundle Analysis": "产物分析",
+  BundleSize: "产物体积分析",
+  "Module Graph": "Module Graph",
+  TreeShaking: "Tree Shaking",
+  "Rule Index": "错误索引信息",
+  Resources: "资源",
+  "Project Overall": "项目信息概览",
+  "Compile Overall": "编译数据概览",
+  "Bundle Overall": "产物数据概览",
+  "Expand Omitted": " reasons 树会默认折叠中间的第三方引入的模块，点击这个图标可以查看完整树图",
+  "Concatenated Tag": "串联模块，hover 上去可以显示聚合成的主模块名称。注：聚合模块 parsed size 为零，有可能是因为被聚合到了主模块中。",
+  "the file content not changed after transpiled by this loader": "该文件内容在 loader 处理前后没有发生变化",
+  /** Bundle Size */
+  "Output Assets List": "产物文件列表",
+  "filter the output assets which size is greater than the input value": "筛选大小大于输入值的产物文件",
+  "filter the modules which size is greater than the input value": "筛选大小大于输入值的模块",
+  "After Compile": "编译后",
+  "After Bundle": "打包后",
+  CodeModeExplain: "Lite 模式下或纯 stats.json 上传的情况下只有 source code.",
+  DuplicatePakCodeExplain: "纯 stats.json 输入的情况下没有代码，可使用 web-doctor 插件参与构建会有对应代码。"
+};
+var cn_default = cn;
+export {
+  cn_default as default
+};

package/dist/utils/i18n/en.d.ts

@@ -0,0 +1,30 @@
+declare const en: {
+  Overall: string;
+  'Compile Analysis': string;
+  LoadersAnalysis: string;
+  'Loaders Overall': string;
+  'Loaders Analysis': string;
+  PluginsAnalysis: string;
+  ModuleResolve: string;
+  'Bundle Analysis': string;
+  BundleSize: string;
+  'Module Graph': string;
+  TreeShaking: string;
+  'Rule Index': string;
+  Resources: string;
+  'Project Overall': string;
+  'Compile Overall': string;
+  'Bundle Overall': string;
+  'Expand Omitted': string;
+  'Concatenated Tag': string;
+  'the file content not changed after transpiled by this loader': string;
+  /** Bundle Size */
+  'Output Assets List': string;
+  'filter the output assets which size is greater than the input value': string;
+  'filter the modules which size is greater than the input value': string;
+  'After Compile': string;
+  'After Bundle': string;
+  CodeModeExplain: string;
+  DuplicatePakCodeExplain: string;
+};
+export default en;

package/dist/utils/i18n/en.js

@@ -0,0 +1,33 @@
+const en = {
+  Overall: "Overall",
+  "Compile Analysis": "Compile Analysis",
+  LoadersAnalysis: "Loaders Analysis",
+  "Loaders Overall": "Loaders Overall",
+  "Loaders Analysis": "Loaders Analysis",
+  PluginsAnalysis: "Plugins Analysis",
+  ModuleResolve: "Module Resolve",
+  "Bundle Analysis": "Bundle Analysis",
+  BundleSize: "Bundle Size",
+  "Module Graph": "Module Graph",
+  TreeShaking: "Tree Shaking",
+  "Rule Index": "Rule Index",
+  Resources: "Resources",
+  "Project Overall": "Project Overall",
+  "Compile Overall": "Compile Overall",
+  "Bundle Overall": "Bundle Overall",
+  "Expand Omitted": "By default, the reasons tree collapses to the middle of the module introduced by a third party. Click on this icon to view the full tree diagram",
+  "Concatenated Tag": "Concatenated Module,hover can display the name of the concatenated main module. Note: the parsed size of the concatenated module is zero, possibly because it is aggregated into the main module.",
+  "the file content not changed after transpiled by this loader": "the file content not changed after transpiled by this loader",
+  /** Bundle Size */
+  "Output Assets List": "Output Assets List",
+  "filter the output assets which size is greater than the input value": "filter the output assets which size is greater than the input value",
+  "filter the modules which size is greater than the input value": "filter the modules which size is greater than the input value",
+  "After Compile": "After Compile",
+  "After Bundle": "After Bundle",
+  CodeModeExplain: "In lite mode or pure stats.json upload, only source code.",
+  DuplicatePakCodeExplain: "There is no code, when in the case of pure stats.json."
+};
+var en_default = en;
+export {
+  en_default as default
+};

package/dist/utils/i18n/index.d.ts

@@ -0,0 +1,2 @@
+import i18n from 'i18next';
+export default i18n;

package/dist/utils/i18n/index.js

@@ -0,0 +1,34 @@
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+import en from "./en";
+import cn from "./cn";
+import { getLocaleFromStorage } from "../storage";
+i18n.use(initReactI18next).init({
+  lng: getLocaleFromStorage(),
+  // we init with resources
+  resources: {
+    en: {
+      translations: en
+    },
+    cn: {
+      translations: cn
+    }
+  },
+  fallbackLng: {
+    "zh-CN": ["cn"],
+    default: ["en"]
+  },
+  debug: process.env.NODE_ENV === "development",
+  // have a common namespace used around the full app
+  ns: ["translations"],
+  defaultNS: "translations",
+  keySeparator: false,
+  // we use content as keys
+  interpolation: {
+    escapeValue: false
+  }
+});
+var i18n_default = i18n;
+export {
+  i18n_default as default
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,16 @@
+export * from './data';
+export * from './file';
+export * from './hooks';
+export * from './locale';
+export * from './manifest';
+export * from './monaco';
+export * from './request';
+export * from './routes';
+export * from './size';
+export * from './socket';
+export * from './storage';
+export * from './string';
+export * from './time';
+export * from './url';
+export * from './worker';
+export * from './loader';

package/dist/utils/index.js

@@ -0,0 +1,16 @@
+export * from "./data";
+export * from "./file";
+export * from "./hooks";
+export * from "./locale";
+export * from "./manifest";
+export * from "./monaco";
+export * from "./request";
+export * from "./routes";
+export * from "./size";
+export * from "./socket";
+export * from "./storage";
+export * from "./string";
+export * from "./time";
+export * from "./url";
+export * from "./worker";
+export * from "./loader";

package/dist/utils/loader.d.ts

@@ -0,0 +1,7 @@
+import { Loader } from '@rsdoctor/utils/common';
+import { SDK } from '@rsdoctor/types';
+declare const findLoaderTotalTiming: typeof Loader.findLoaderTotalTiming, getLoaderCosts: typeof Loader.getLoaderCosts;
+export { findLoaderTotalTiming, getLoaderCosts };
+export declare function flattenLoaderData(loaderData: SDK.LoaderData): SDK.LoaderTransformData[];
+export declare function filterLoaders(loaderData: SDK.ResourceLoaderData, keyword: string, loaderNames: string[]): SDK.LoaderTransformData[];
+export declare function filterLoader(resourcePath: string, loader: string, keyword: string, loaderNames: string[]): boolean;

package/dist/utils/loader.js

@@ -0,0 +1,29 @@
+import { Loader } from "@rsdoctor/utils/common";
+import { flatten, includes } from "lodash-es";
+const { findLoaderTotalTiming, getLoaderCosts } = Loader;
+function flattenLoaderData(loaderData) {
+  return flatten(loaderData.map((e) => e.loaders));
+}
+function filterLoaders(loaderData, keyword, loaderNames) {
+  return loaderData.loaders.filter((item) => {
+    return filterLoader(loaderData.resource.path, item.loader, keyword, loaderNames);
+  });
+}
+function filterLoader(resourcePath, loader, keyword, loaderNames) {
+  if (keyword) {
+    if (resourcePath.indexOf(keyword) === -1)
+      return false;
+  }
+  if (loaderNames && loaderNames.length) {
+    if (!includes(loaderNames, loader))
+      return false;
+  }
+  return true;
+}
+export {
+  filterLoader,
+  filterLoaders,
+  findLoaderTotalTiming,
+  flattenLoaderData,
+  getLoaderCosts
+};

package/dist/utils/locale.d.ts

@@ -0,0 +1,2 @@
+import type { Locale } from 'antd/es/locale';
+export declare function getLocale(locale: string): Locale;

package/dist/utils/locale.js

@@ -0,0 +1,9 @@
+import cn from "antd/es/locale/zh_CN";
+import en from "antd/es/locale/en_GB";
+function getLocale(locale) {
+  const res = locale === "cn" || locale === "zh-CN" ? cn : en;
+  return res;
+}
+export {
+  getLocale
+};