@rsdoctor/components 0.0.2-beta.0

package/dist/pages/WebpackLoaders/Analysis/constants.js

@@ -0,0 +1,7 @@
+import { Client } from "@rsdoctor/types";
+const name = "Loaders Analysis";
+const route = Client.DoctorClientRoutes.WebpackLoaderAnalysis;
+export {
+  name,
+  route
+};

package/dist/pages/WebpackLoaders/Analysis/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/WebpackLoaders/Analysis/index.js

@@ -0,0 +1,19 @@
+import { jsx } from "react/jsx-runtime";
+import { LoaderAnalysis } from "../../../components/Loader/Analysis";
+import { WebpackConfigurationViewer } from "../../../components/Configuration";
+import { Card } from "../../../components/Card";
+const Page = () => {
+  return /* @__PURE__ */ jsx(
+    Card,
+    {
+      title: "Webpack Loader Analysis",
+      extra: /* @__PURE__ */ jsx(WebpackConfigurationViewer, { defaultKeys: ["module", "resolve"] }),
+      bodyStyle: { paddingTop: 0 },
+      children: /* @__PURE__ */ jsx(LoaderAnalysis, {})
+    }
+  );
+};
+export * from "./constants";
+export {
+  Page
+};

package/dist/pages/WebpackLoaders/Overall/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "Loaders Overall";
+export declare const route = Client.DoctorClientRoutes.WebpackLoaderOverall;

package/dist/pages/WebpackLoaders/Overall/constants.js

@@ -0,0 +1,7 @@
+import { Client } from "@rsdoctor/types";
+const name = "Loaders Overall";
+const route = Client.DoctorClientRoutes.WebpackLoaderOverall;
+export {
+  name,
+  route
+};

package/dist/pages/WebpackLoaders/Overall/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/WebpackLoaders/Overall/index.js

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { WebpackConfigurationViewer } from "../../../components/Configuration";
+import { Card } from "../../../components/Card";
+import { LoaderChart } from "../../../components/Charts";
+const Page = () => {
+  return /* @__PURE__ */ jsx(Card, { title: "Loader Overall", extra: /* @__PURE__ */ jsx(WebpackConfigurationViewer, { defaultKeys: ["module"] }), collapsable: true, children: /* @__PURE__ */ jsx(LoaderChart, {}) });
+};
+export * from "./constants";
+export {
+  Page
+};

package/dist/pages/WebpackLoaders/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const name = "Loaders";
+export declare const route = "/webpack/loaders";

package/dist/pages/WebpackLoaders/constants.js

@@ -0,0 +1,6 @@
+const name = "Loaders";
+const route = "/webpack/loaders";
+export {
+  name,
+  route
+};

package/dist/pages/WebpackPlugins/constants.d.ts

@@ -0,0 +1,3 @@
+import { Client } from '@rsdoctor/types';
+export declare const name = "WebpackPlugins";
+export declare const route = Client.DoctorClientRoutes.WebpackPlugins;

package/dist/pages/WebpackPlugins/constants.js

@@ -0,0 +1,7 @@
+import { Client } from "@rsdoctor/types";
+const name = "WebpackPlugins";
+const route = Client.DoctorClientRoutes.WebpackPlugins;
+export {
+  name,
+  route
+};

package/dist/pages/WebpackPlugins/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const Page: React.FC;
+export * from './constants';

package/dist/pages/WebpackPlugins/index.js

@@ -0,0 +1,79 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ApiOutlined, PartitionOutlined } from "@ant-design/icons";
+import { SDK } from "@rsdoctor/types";
+import { Button, Card, Input, Select, Space, Typography } from "antd";
+import { useState } from "react";
+import { WebpackConfigurationViewer } from "../../components/Configuration";
+import { ServerAPIProvider } from "../../components/Manifest";
+import { WebpackPluginsDataTable } from "../../components/Plugins/webpack";
+import { Size } from "../../constants";
+const Page = () => {
+  const [selectedTapNames, setSelectedTapNames] = useState([]);
+  const [selectedHooks, setSelectedHooks] = useState([]);
+  return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+    Card,
+    {
+      title: "Webpack Plugins Overall",
+      bodyStyle: { paddingTop: Size.BasePadding / 3 },
+      extra: /* @__PURE__ */ jsx(WebpackConfigurationViewer, { defaultKeys: ["plugins"] }),
+      children: /* @__PURE__ */ jsxs(Space, { direction: "vertical", children: [
+        /* @__PURE__ */ jsx(ServerAPIProvider, { api: SDK.ServerAPI.API.GetPluginSummary, children: ({ hooks, tapNames }) => /* @__PURE__ */ jsxs(Space, { style: { marginBottom: Size.BasePadding / 2 }, children: [
+          /* @__PURE__ */ jsxs(Input.Group, { compact: true, children: [
+            /* @__PURE__ */ jsxs(Button, { children: [
+              /* @__PURE__ */ jsx(ApiOutlined, {}),
+              /* @__PURE__ */ jsx(Typography.Text, { children: "Plugin Tap Names" })
+            ] }),
+            /* @__PURE__ */ jsx(
+              Select,
+              {
+                mode: "multiple",
+                allowClear: true,
+                style: { width: 350 },
+                dropdownMatchSelectWidth: true,
+                onChange: (e) => {
+                  setSelectedTapNames(e);
+                },
+                children: tapNames.map((e) => {
+                  return /* @__PURE__ */ jsx(Select.Option, { label: e, value: e, children: e }, e);
+                })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs(Input.Group, { compact: true, children: [
+            /* @__PURE__ */ jsxs(Button, { children: [
+              /* @__PURE__ */ jsx(PartitionOutlined, {}),
+              /* @__PURE__ */ jsx(Typography.Text, { children: "Hooks" })
+            ] }),
+            /* @__PURE__ */ jsx(
+              Select,
+              {
+                mode: "multiple",
+                allowClear: true,
+                style: { width: 350 },
+                dropdownMatchSelectWidth: true,
+                onChange: (e) => {
+                  setSelectedHooks(e);
+                },
+                children: hooks.map((e) => {
+                  return /* @__PURE__ */ jsx(Select.Option, { label: e, value: e, children: e }, e);
+                })
+              }
+            )
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx(
+          ServerAPIProvider,
+          {
+            api: SDK.ServerAPI.API.GetPluginData,
+            body: { hooks: selectedHooks, tapNames: selectedTapNames },
+            children: (res) => /* @__PURE__ */ jsx(WebpackPluginsDataTable, { dataSource: res })
+          }
+        )
+      ] })
+    }
+  ) });
+};
+export * from "./constants";
+export {
+  Page
+};

package/dist/pages/index.d.ts

@@ -0,0 +1,7 @@
+export * as Overall from './Overall';
+export * as BundleSize from './BundleSize';
+export * as ModuleAnalyze from './ModuleAnalyze';
+export * as LoaderTimeline from './WebpackLoaders/Overall';
+export * as LoaderFiles from './WebpackLoaders/Analysis';
+export * as PluginsAnalyze from './WebpackPlugins';
+export * as ModuleResolve from './ModuleResolve';

package/dist/pages/index.js

@@ -0,0 +1,16 @@
+import * as Overall from "./Overall";
+import * as BundleSize from "./BundleSize";
+import * as ModuleAnalyze from "./ModuleAnalyze";
+import * as LoaderTimeline from "./WebpackLoaders/Overall";
+import * as LoaderFiles from "./WebpackLoaders/Analysis";
+import * as PluginsAnalyze from "./WebpackPlugins";
+import * as ModuleResolve from "./ModuleResolve";
+export {
+  BundleSize,
+  LoaderFiles,
+  LoaderTimeline,
+  ModuleAnalyze,
+  ModuleResolve,
+  Overall,
+  PluginsAnalyze
+};

package/dist/utils/data/base.d.ts

@@ -0,0 +1,24 @@
+import { Common, Manifest, SDK } from '@rsdoctor/types';
+import { Data } from '@rsdoctor/utils/common';
+export declare abstract class BaseDataLoader implements Manifest.ManifestDataLoader {
+  protected manifest: Manifest.DoctorManifestWithShardingFiles;
+  protected pool: Map<string, Promise<unknown>>;
+  protected loader: Data.APIDataLoader;
+  protected disposed: boolean;
+  protected shardingDataMap: Map<keyof Manifest.DoctorManifestData, Promise<any>>;
+  constructor(manifest: Manifest.DoctorManifestWithShardingFiles);
+  protected get<T extends keyof Manifest.DoctorManifestWithShardingFiles>(key: T): void | Manifest.DoctorManifestWithShardingFiles[T];
+  protected getData<T extends keyof Manifest.DoctorManifestData>(key: T, scope?: 'data'): void | Manifest.DoctorManifestWithShardingFiles['data'][T];
+  protected getKeys(key: string): string[];
+  protected joinKeys(keys: string[]): string;
+  dispose(): void;
+  limit<T>(key: string, fn: Common.Function<unknown[], Promise<T>>): Promise<T>;
+  log(...args: unknown[]): void;
+  loadManifest(): Promise<Manifest.DoctorManifestWithShardingFiles>;
+  abstract loadData<T extends string, P>(key: T): Promise<void | P>;
+  abstract loadData<T extends Manifest.DoctorManifestMappingKeys>(key: T): Promise<void | Manifest.InferManifestDataValue<T>>;
+  abstract isLocal(): boolean;
+  abstract loadAPI<T extends SDK.ServerAPI.API, B extends SDK.ServerAPI.InferRequestBodyType<T> = SDK.ServerAPI.InferRequestBodyType<T>, R extends SDK.ServerAPI.InferResponseType<T> = SDK.ServerAPI.InferResponseType<T>>(...args: B extends void ? [api: T] : [api: T, body: B]): Promise<R>;
+  abstract onDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+  abstract removeOnDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+}

package/dist/utils/data/base.js

@@ -0,0 +1,70 @@
+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 { Data } from "@rsdoctor/utils/common";
+class BaseDataLoader {
+  constructor(manifest) {
+    this.manifest = manifest;
+    this.pool = /* @__PURE__ */ new Map();
+    this.disposed = false;
+    this.shardingDataMap = /* @__PURE__ */ new Map();
+    this.loader = new Data.APIDataLoader(this);
+    console.log("[DataLoader] isLocal: ", this.isLocal());
+  }
+  get(key) {
+    if (!this.manifest)
+      return;
+    return this.manifest[key];
+  }
+  getData(key, scope = "data") {
+    const data = this.get(scope);
+    if (!data)
+      return;
+    return data[key];
+  }
+  getKeys(key) {
+    return key.split(".");
+  }
+  joinKeys(keys) {
+    return keys.join(".");
+  }
+  dispose() {
+    this.disposed = true;
+  }
+  limit(key, fn) {
+    if (this.pool.has(key)) {
+      return this.pool.get(key);
+    }
+    const res = fn().finally(() => this.pool.delete(key));
+    this.pool.set(key, res);
+    return res;
+  }
+  log(...args) {
+    console.log(`[${this.constructor.name}]`, ...args);
+  }
+  loadManifest() {
+    return __async(this, null, function* () {
+      return this.manifest;
+    });
+  }
+}
+export {
+  BaseDataLoader
+};

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

@@ -0,0 +1,5 @@
+import { Manifest } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare function useDataLoader(manifest: Manifest.DoctorManifestWithShardingFiles | void): {
+  loader: void | BaseDataLoader;
+};

package/dist/utils/data/index.js

@@ -0,0 +1,66 @@
+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 { useEffect, useState } from "react";
+import { LocalServerDataLoader } from "./local";
+import { RemoteDataLoader } from "./remote";
+import { getAPILoaderModeFromStorage } from "../storage";
+import { APILoaderMode4Dev } from "../../constants";
+const loaderTask = /* @__PURE__ */ new WeakMap();
+function createDataLoader(manifest) {
+  return __async(this, null, function* () {
+    try {
+      if (process.env.NODE_ENV === "development") {
+        const mode = getAPILoaderModeFromStorage();
+        if (mode === APILoaderMode4Dev.Local)
+          return new LocalServerDataLoader(manifest);
+        if (mode === APILoaderMode4Dev.Remote)
+          return new RemoteDataLoader(manifest);
+      }
+      if (manifest.__LOCAL__SERVER__) {
+        return new LocalServerDataLoader(manifest);
+      }
+    } catch (error) {
+      console.log("[DataLoader] fallback to RemoteDataLoader");
+    }
+    return new RemoteDataLoader(manifest);
+  });
+}
+function useDataLoader(manifest) {
+  const [loader, setLoader] = useState(void 0);
+  useEffect(() => {
+    if (!manifest)
+      return;
+    if (!loaderTask.has(manifest)) {
+      const promise = createDataLoader(manifest);
+      loaderTask.set(manifest, promise);
+    }
+    const task = loaderTask.get(manifest);
+    task.then((loader2) => {
+      setLoader(loader2);
+    });
+  }, [manifest]);
+  return {
+    loader
+  };
+}
+export {
+  useDataLoader
+};

package/dist/utils/data/local.d.ts

@@ -0,0 +1,14 @@
+import { Common, Manifest, SDK } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare class LocalServerDataLoader extends BaseDataLoader {
+  protected events: Map<SDK.ServerAPI.API | SDK.ServerAPI.APIExtends, Set<Common.Function>>;
+  isLocal(): boolean;
+  loadData<T extends keyof Manifest.DoctorManifestData>(key: T): Promise<void | Manifest.DoctorManifestData[T]>;
+  loadAPI<T extends SDK.ServerAPI.API, B extends SDK.ServerAPI.InferRequestBodyType<T> = SDK.ServerAPI.InferRequestBodyType<T>, R extends SDK.ServerAPI.InferResponseType<T> = SDK.ServerAPI.InferResponseType<T>>(...args: B extends void ? [api: T] : [api: T, body: B]): Promise<R>;
+  dispose(): void;
+  /**
+   * add event listener when received data from server.
+   */
+  onDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+  removeOnDataUpdate<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, fn: (response: SDK.ServerAPI.SocketResponseType<T>) => void): void;
+}

package/dist/utils/data/local.js

@@ -0,0 +1,106 @@
+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 { Manifest as ManifestShared } from "@rsdoctor/utils/common";
+import { SDK } from "@rsdoctor/types";
+import { get } from "lodash-es";
+import { BaseDataLoader } from "./base";
+import { getSocket } from "../socket";
+class LocalServerDataLoader extends BaseDataLoader {
+  constructor() {
+    super(...arguments);
+    this.events = /* @__PURE__ */ new Map();
+  }
+  isLocal() {
+    return true;
+  }
+  loadData(key) {
+    return __async(this, null, function* () {
+      return this.limit(key, () => __async(this, null, function* () {
+        const [scope, ...rest] = this.getKeys(key);
+        const data = this.getData(scope);
+        if (!data)
+          return;
+        let res = data;
+        if (ManifestShared.isShardingData(res)) {
+          if (!this.shardingDataMap.has(key)) {
+            const task = new Promise((resolve) => {
+              getSocket(this.manifest.__SOCKET__URL__).emit(
+                SDK.ServerAPI.API.LoadDataByKey,
+                { key },
+                (res2) => {
+                  resolve(res2.res);
+                }
+              );
+            });
+            this.shardingDataMap.set(key, task);
+          }
+          res = yield this.shardingDataMap.get(key);
+          this.shardingDataMap.delete(key);
+          return res;
+        }
+        return rest.length > 0 ? get(res, this.joinKeys(rest)) : res;
+      }));
+    });
+  }
+  loadAPI(...args) {
+    return __async(this, null, function* () {
+      const [api, body] = args;
+      const key = body ? `${api}_${JSON.stringify(body)}` : `${api}`;
+      return this.limit(key, () => __async(this, null, function* () {
+        return new Promise((resolve) => {
+          getSocket(this.manifest.__SOCKET__URL__).emit(api, body, (res) => {
+            resolve(res.res);
+          });
+        });
+      }));
+    });
+  }
+  dispose() {
+    super.dispose();
+    this.events.forEach((evs, api) => {
+      evs.forEach((ev) => {
+        this.removeOnDataUpdate(api, ev);
+      });
+      evs.clear();
+    });
+    this.events.clear();
+  }
+  /**
+   * add event listener when received data from server.
+   */
+  onDataUpdate(api, fn) {
+    if (!this.events.has(api)) {
+      this.events.set(api, /* @__PURE__ */ new Set());
+    }
+    if (this.events.get(api).has(fn)) {
+      return;
+    }
+    this.events.get(api).add(fn);
+    getSocket(this.manifest.__SOCKET__URL__).on(api, fn);
+  }
+  removeOnDataUpdate(api, fn) {
+    getSocket(this.manifest.__SOCKET__URL__).off(api, fn);
+    this.events.get(api).delete(fn);
+  }
+}
+export {
+  LocalServerDataLoader
+};

package/dist/utils/data/remote.d.ts

@@ -0,0 +1,10 @@
+import { Manifest, SDK } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare class RemoteDataLoader extends BaseDataLoader {
+  isLocal(): boolean;
+  loadData<T extends Manifest.DoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+  loadAPI<T extends SDK.ServerAPI.API, B extends SDK.ServerAPI.InferRequestBodyType<T> = SDK.ServerAPI.InferRequestBodyType<T>, R extends SDK.ServerAPI.InferResponseType<T> = SDK.ServerAPI.InferResponseType<T>>(...args: B extends void ? [api: T] : [api: T, body: B]): Promise<R>;
+  dispose(): void;
+  onDataUpdate(): void;
+  removeOnDataUpdate(): void;
+}

package/dist/utils/data/remote.js

@@ -0,0 +1,70 @@
+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 { Manifest as ManifestShared } from "@rsdoctor/utils/common";
+import { get } from "lodash-es";
+import { BaseDataLoader } from "./base";
+import { fetchShardingFile } from "../request";
+class RemoteDataLoader extends BaseDataLoader {
+  isLocal() {
+    return false;
+  }
+  loadData(key) {
+    return __async(this, null, function* () {
+      return this.limit(key, () => __async(this, null, function* () {
+        const [scope, ...rest] = this.getKeys(key);
+        const data = this.getData(scope);
+        if (!data)
+          return;
+        let res = data;
+        if (ManifestShared.isShardingData(res)) {
+          if (!this.shardingDataMap.has(scope)) {
+            const task = ManifestShared.fetchShardingData(res, fetchShardingFile).catch((err) => {
+              this.log(`loadData error: `, res, key);
+              throw err;
+            });
+            this.shardingDataMap.set(scope, task);
+          }
+          res = yield this.shardingDataMap.get(scope);
+        }
+        return rest.length > 0 ? get(res, this.joinKeys(rest)) : res;
+      }));
+    });
+  }
+  loadAPI(...args) {
+    return __async(this, null, function* () {
+      const [api, body] = args;
+      const key = body ? `${api}_${JSON.stringify(body)}` : `${api}`;
+      return this.limit(key, () => __async(this, null, function* () {
+        return this.loader.loadAPI(...args);
+      }));
+    });
+  }
+  dispose() {
+    super.dispose();
+  }
+  onDataUpdate() {
+  }
+  removeOnDataUpdate() {
+  }
+}
+export {
+  RemoteDataLoader
+};

package/dist/utils/file.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import { Common } from '@rsdoctor/types';
+import { UploadFile } from 'antd';
+import { FieldDataNode } from 'rc-tree';
+export type DataNode = FieldDataNode<{
+  key: string | number;
+  title?: React.ReactNode | ((data: DataNode) => React.ReactNode);
+}> & {
+  __BASENAME__?: any;
+  __RESOURCEPATH__?: any;
+  children?: DataNode[];
+};
+export declare const rootDirname: (file: string, sep?: string) => string | null;
+export declare function mapFileKey(arr: DataNode[], depth?: number, filter?: (node: DataNode) => boolean): DataNode['key'][];
+export declare function flattenDirectory(n: DataNode, parent: DataNode, sep: string | undefined, inlinedResourcePathKey: keyof DataNode, dirTitle?: (_dir: DataNode, defaultTitle: string) => JSX.Element | string): void;
+export declare function createFileStructures({
+  files,
+  sep,
+  inlinedResourcePathKey,
+  fileTitle,
+  dirTitle
+}: {
+  files: string[];
+  cwd?: string;
+  sep?: string;
+  inlinedResourcePathKey?: keyof DataNode;
+  dirTitle?(dir: DataNode, defaultTitle: string): JSX.Element | string;
+  fileTitle?(file: string, basename: string): JSX.Element | string;
+}): DataNode[];
+export declare function beautifyPath(path: string, cwd: string): string;
+export declare function readJSONByFileReader<T extends Common.PlainObject>(file: UploadFile): Promise<T>;
+export declare function readJSONByFileReader<T extends Common.PlainObject>(file: Blob): Promise<T>;
+/**
+ * beautify module path, will replace cwd & last 'node_modules'
+ */
+export declare function beautifyModulePath(modulePath: string, cwd: string): {
+  alias: string;
+  inNodeModules: boolean;
+};