@rsdoctor/sdk 0.1.0 → 0.1.2

package/README.md

@@ -1,11 +1,18 @@
-# Rsdoctor
+# Rsdoctor SDK
 
-Rsdoctor is a tool for diagnosing and analyzing the build process and build artifacts to help developers quickly identify and solve problems.
+This package is the intermediate data layer of Rsdoctor.
 
-It also supports Webpack and Rspack builders, as well as various build frameworks, such as Rsbuild.
+## features
+
+- Rsdoctor is a one-stop tool for diagnosing and analyzing the build process and build artifacts.
+- Rsdoctor is a tool that supports Webpack and Rspack build analysis.
+- Rsdoctor is an analysis tool that can display the time-consuming and behavioral details of the compilation.
+- Rsdoctor is a tool that provides bundle Diff and other anti-degradation capabilities simultaneously.
 
 ## Documentation
 
+https://rsdoctor.dev/
+
 ## Contributing
 
 Please read the [Contributing Guide](https://github.com/web-infra-dev/rsdoctor/blob/main/CONTRIBUTING.md).

package/dist/cjs/sdk/server/index.js

@@ -37,13 +37,14 @@ var import_build = require("@rsdoctor/utils/build");
 var import_common = require("@rsdoctor/utils/common");
 var import_assert = __toESM(require("assert"));
 var import_body_parser = __toESM(require("body-parser"));
-var import_open = __toESM(require("open"));
 var import_ip = __toESM(require("ip"));
 var import_cors = __toESM(require("cors"));
 var import_stream = require("stream");
 var import_socket = require("./socket");
 var import_router = require("./router");
 var APIs = __toESM(require("./apis"));
+var import_logger = require("@rsdoctor/utils/logger");
+var import_openBrowser = require("../utils/openBrowser");
 __reExport(server_exports, require("./utils"), module.exports);
 class RsdoctorServer {
   constructor(sdk, port = import_build.Server.defaultPort) {
@@ -77,12 +78,15 @@ class RsdoctorServer {
   get app() {
     return this._server.app;
   }
-  get origin() {
+  get host() {
     const host = import_ip.default.address();
-    return `http://${host}:${this.port}`;
+    return host;
+  }
+  get origin() {
+    return `http://${this.host}:${this.port}`;
   }
   get socketUrl() {
-    return `ws://${import_ip.default.address()}:${this.port}`;
+    return `ws://localhost:${this.port}`;
   }
   async bootstrap() {
     if (!this.disposed) {
@@ -152,23 +156,28 @@ class RsdoctorServer {
     });
   }
   getClientUrl(route = "homepage", ...args) {
-    const url = `${this.origin}${import_types.SDK.ServerAPI.API.EntryHtml}`;
+    const relativeUrl = import_types.SDK.ServerAPI.API.EntryHtml;
     switch (route) {
       case import_types.Client.RsdoctorClientRoutes.BundleDiff: {
         const [baseline, current] = args;
         const qs = import_common.Bundle.getBundleDiffPageQueryString([baseline, current]);
-        return `${url}${qs}#${import_types.Client.RsdoctorClientRoutes.BundleDiff}`;
+        return `${relativeUrl}${qs}#${import_types.Client.RsdoctorClientRoutes.BundleDiff}`;
       }
       default:
-        return url;
+        return relativeUrl;
     }
   }
   async openClientPage(...args) {
-    const url = this.getClientUrl(
+    const relativeUrl = this.getClientUrl(
       ...args
     );
-    await (0, import_open.default)(url);
-    console.log(`Rsdoctor analyze run at: ${url}`);
+    const url = `http://${this.host}:${this.port}${relativeUrl}`;
+    const localhostUrl = `http://localhost:${this.port}${relativeUrl}`;
+    await (0, import_openBrowser.openBrowser)(url);
+    import_logger.logger.info(`Rsdoctor analyze server running on: ${import_logger.chalk.cyan(url)}`);
+    import_logger.logger.info(
+      `Rsdoctor analyze server running on: ${import_logger.chalk.cyan(localhostUrl)}`
+    );
   }
   sendAPIDataToClient(api, msg) {
     this._socket?.sendAPIData(api, msg);

package/dist/cjs/sdk/utils/openBrowser.js

@@ -0,0 +1,92 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var openBrowser_exports = {};
+__export(openBrowser_exports, {
+  openBrowser: () => openBrowser
+});
+module.exports = __toCommonJS(openBrowser_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_util = require("node:util");
+var import_logger = require("@rsdoctor/utils/logger");
+var import_open = __toESM(require("open"));
+var import_node_path = require("node:path");
+const execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+const supportedChromiumBrowsers = [
+  "Google Chrome Canary",
+  "Google Chrome Dev",
+  "Google Chrome Beta",
+  "Google Chrome",
+  "Microsoft Edge",
+  "Brave Browser",
+  "Vivaldi",
+  "Chromium"
+];
+const getTargetBrowser = async () => {
+  let targetBrowser = process.env.BROWSER;
+  if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
+    const { stdout: ps } = await execAsync("ps cax");
+    targetBrowser = supportedChromiumBrowsers.find((b) => ps.includes(b));
+  }
+  return targetBrowser;
+};
+async function openBrowser(url) {
+  const shouldTryOpenChromeWithAppleScript = process.platform === "darwin";
+  if (shouldTryOpenChromeWithAppleScript) {
+    try {
+      const targetBrowser = await getTargetBrowser();
+      if (targetBrowser) {
+        await execAsync(
+          `osascript openChrome.applescript "${encodeURI(
+            url
+          )}" "${targetBrowser}"`,
+          {
+            cwd: (0, import_node_path.join)(__dirname, "../../../../static")
+          }
+        );
+        return true;
+      }
+      import_logger.logger.debug("Failed to find the target browser.");
+    } catch (err) {
+      import_logger.logger.debug("Failed to open Rsdoctor URL with apple script.");
+      import_logger.logger.debug(err);
+    }
+  }
+  try {
+    await (0, import_open.default)(url);
+    return true;
+  } catch (err) {
+    import_logger.logger.error("Failed to open Rsdoctor URL.");
+    import_logger.logger.error(err);
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openBrowser
+});

package/dist/esm/sdk/server/index.js

@@ -3,13 +3,14 @@ import { Server } from "@rsdoctor/utils/build";
 import { Bundle } from "@rsdoctor/utils/common";
 import assert from "assert";
 import bodyParser from "body-parser";
-import open from "open";
 import ip from "ip";
 import cors from "cors";
 import { PassThrough } from "stream";
 import { Socket } from "./socket";
 import { Router } from "./router";
 import * as APIs from "./apis";
+import { chalk, logger } from "@rsdoctor/utils/logger";
+import { openBrowser } from "../utils/openBrowser";
 export * from "./utils";
 class RsdoctorServer {
   constructor(sdk, port = Server.defaultPort) {
@@ -43,12 +44,15 @@ class RsdoctorServer {
   get app() {
     return this._server.app;
   }
-  get origin() {
+  get host() {
     const host = ip.address();
-    return `http://${host}:${this.port}`;
+    return host;
+  }
+  get origin() {
+    return `http://${this.host}:${this.port}`;
   }
   get socketUrl() {
-    return `ws://${ip.address()}:${this.port}`;
+    return `ws://localhost:${this.port}`;
   }
   async bootstrap() {
     if (!this.disposed) {
@@ -118,23 +122,28 @@ class RsdoctorServer {
     });
   }
   getClientUrl(route = "homepage", ...args) {
-    const url = `${this.origin}${SDK.ServerAPI.API.EntryHtml}`;
+    const relativeUrl = SDK.ServerAPI.API.EntryHtml;
     switch (route) {
       case Client.RsdoctorClientRoutes.BundleDiff: {
         const [baseline, current] = args;
         const qs = Bundle.getBundleDiffPageQueryString([baseline, current]);
-        return `${url}${qs}#${Client.RsdoctorClientRoutes.BundleDiff}`;
+        return `${relativeUrl}${qs}#${Client.RsdoctorClientRoutes.BundleDiff}`;
       }
       default:
-        return url;
+        return relativeUrl;
     }
   }
   async openClientPage(...args) {
-    const url = this.getClientUrl(
+    const relativeUrl = this.getClientUrl(
       ...args
     );
-    await open(url);
-    console.log(`Rsdoctor analyze run at: ${url}`);
+    const url = `http://${this.host}:${this.port}${relativeUrl}`;
+    const localhostUrl = `http://localhost:${this.port}${relativeUrl}`;
+    await openBrowser(url);
+    logger.info(`Rsdoctor analyze server running on: ${chalk.cyan(url)}`);
+    logger.info(
+      `Rsdoctor analyze server running on: ${chalk.cyan(localhostUrl)}`
+    );
   }
   sendAPIDataToClient(api, msg) {
     this._socket?.sendAPIData(api, msg);

package/dist/esm/sdk/utils/openBrowser.js

@@ -0,0 +1,58 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "@rsdoctor/utils/logger";
+import open from "open";
+import { join } from "node:path";
+const execAsync = promisify(exec);
+const supportedChromiumBrowsers = [
+  "Google Chrome Canary",
+  "Google Chrome Dev",
+  "Google Chrome Beta",
+  "Google Chrome",
+  "Microsoft Edge",
+  "Brave Browser",
+  "Vivaldi",
+  "Chromium"
+];
+const getTargetBrowser = async () => {
+  let targetBrowser = process.env.BROWSER;
+  if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
+    const { stdout: ps } = await execAsync("ps cax");
+    targetBrowser = supportedChromiumBrowsers.find((b) => ps.includes(b));
+  }
+  return targetBrowser;
+};
+async function openBrowser(url) {
+  const shouldTryOpenChromeWithAppleScript = process.platform === "darwin";
+  if (shouldTryOpenChromeWithAppleScript) {
+    try {
+      const targetBrowser = await getTargetBrowser();
+      if (targetBrowser) {
+        await execAsync(
+          `osascript openChrome.applescript "${encodeURI(
+            url
+          )}" "${targetBrowser}"`,
+          {
+            cwd: join(__dirname, "../../../../static")
+          }
+        );
+        return true;
+      }
+      logger.debug("Failed to find the target browser.");
+    } catch (err) {
+      logger.debug("Failed to open Rsdoctor URL with apple script.");
+      logger.debug(err);
+    }
+  }
+  try {
+    await open(url);
+    return true;
+  } catch (err) {
+    logger.error("Failed to open Rsdoctor URL.");
+    logger.error(err);
+    return false;
+  }
+}
+export {
+  openBrowser
+};

package/dist/type/index.d.ts

@@ -1 +1 @@
-export * from './sdk';
+export * from './sdk';

package/dist/type/sdk/index.d.ts

@@ -1,2 +1,2 @@
 export * from './sdk';
-export * from './multiple';
+export * from './multiple';

package/dist/type/sdk/multiple/controller.d.ts

@@ -1,16 +1,12 @@
 import { Manifest } from '@rsdoctor/types';
 import { RsdoctorSlaveSDK } from './slave';
 export declare class RsdoctorSDKController {
-  readonly slaves: RsdoctorSlaveSDK[];
-  root: string;
-  constructor(root?: string);
-  get master(): RsdoctorSlaveSDK;
-  getLastSdk(): RsdoctorSlaveSDK;
-  hasName(name: string): boolean;
-  getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
-  createSlave({
-    name,
-    stage,
-    extraConfig
-  }: Omit<ConstructorParameters<typeof RsdoctorSlaveSDK>[0], 'controller'>): RsdoctorSlaveSDK;
-}
+    readonly slaves: RsdoctorSlaveSDK[];
+    root: string;
+    constructor(root?: string);
+    get master(): RsdoctorSlaveSDK;
+    getLastSdk(): RsdoctorSlaveSDK;
+    hasName(name: string): boolean;
+    getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
+    createSlave({ name, stage, extraConfig, }: Omit<ConstructorParameters<typeof RsdoctorSlaveSDK>[0], 'controller'>): RsdoctorSlaveSDK;
+}

package/dist/type/sdk/multiple/index.d.ts

@@ -1,2 +1,2 @@
 export * from './controller';
-export * from './slave';
+export * from './slave';

package/dist/type/sdk/multiple/server.d.ts

@@ -1,7 +1,7 @@
 import { RsdoctorServer } from '../server';
 import type { RsdoctorSlaveSDK } from './slave';
 export declare class RsdoctorSlaveServer extends RsdoctorServer {
-  protected sdk: RsdoctorSlaveSDK;
-  constructor(sdk: RsdoctorSlaveSDK, port?: number);
-  openClientPage(...args: unknown[]): Promise<void>;
-}
+    protected sdk: RsdoctorSlaveSDK;
+    constructor(sdk: RsdoctorSlaveSDK, port?: number);
+    openClientPage(...args: unknown[]): Promise<void>;
+}

package/dist/type/sdk/multiple/slave.d.ts

@@ -2,34 +2,29 @@ import { SDK } from '@rsdoctor/types';
 import { RsdoctorWebpackSDK } from '../sdk';
 import type { RsdoctorSDKController } from './controller';
 interface RsdoctorSlaveSDKOptions {
-  name: string;
-  /**
-   * use to sort for display in the client page.
-   * the smaller the front.
-   * @default 1
-   */
-  stage?: number;
-  extraConfig?: SDK.SDKOptionsType;
-  controller: RsdoctorSDKController;
+    name: string;
+    /**
+     * use to sort for display in the client page.
+     * the smaller the front.
+     * @default 1
+     */
+    stage?: number;
+    extraConfig?: SDK.SDKOptionsType;
+    controller: RsdoctorSDKController;
 }
 export declare class RsdoctorSlaveSDK extends RsdoctorWebpackSDK {
-  id: number;
-  readonly stage: number;
-  private parent;
-  private uploadPieces;
-  private finishUploadPieceSwitch;
-  constructor({
-    name,
-    stage,
-    controller,
-    extraConfig
-  }: RsdoctorSlaveSDKOptions);
-  private clearSwitch;
-  get isMaster(): boolean;
-  protected writePieces(): Promise<void>;
-  protected writeManifest(): Promise<string>;
-  getSeriesData(serverUrl?: boolean): import("@rsdoctor/types/dist/manifest").RsdoctorManifestSeriesData[];
-  setName(name: string): void;
-  getManifestData(): import("@rsdoctor/types/dist/manifest").RsdoctorManifestWithShardingFiles;
+    id: number;
+    readonly stage: number;
+    private parent;
+    private uploadPieces;
+    private finishUploadPieceSwitch;
+    constructor({ name, stage, controller, extraConfig }: RsdoctorSlaveSDKOptions);
+    private clearSwitch;
+    get isMaster(): boolean;
+    protected writePieces(): Promise<void>;
+    protected writeManifest(): Promise<string>;
+    getSeriesData(serverUrl?: boolean): import("@rsdoctor/types/dist/manifest").RsdoctorManifestSeriesData[];
+    setName(name: string): void;
+    getManifestData(): import("@rsdoctor/types/dist/manifest").RsdoctorManifestWithShardingFiles;
 }
-export {};
+export {};

package/dist/type/sdk/sdk/core.d.ts

@@ -1,35 +1,32 @@
 import { Common, Manifest, SDK } from '@rsdoctor/types';
 import { RsdoctorSDKOptions, DataWithUrl } from './types';
 export declare abstract class SDKCore<T extends RsdoctorSDKOptions> implements SDK.RsdoctorSDKInstance {
-  protected _name: string;
-  protected hash: string;
-  extraConfig: SDK.SDKOptionsType | undefined;
-  readonly root: string;
-  readonly pid: number;
-  readonly hooks: SDK.Hooks;
-  protected _envinfo: SDK.EnvInfo;
-  private _clientRoutes;
-  private _outputDir;
-  diskManifestPath: string;
-  cloudData?: Manifest.RsdoctorManifestWithShardingFiles;
-  constructor({
-    name,
-    root
-  }: T);
-  get outputDir(): string;
-  get name(): string;
-  bootstrap(): Promise<void>;
-  dispose(): Promise<void>;
-  setOutputDir(outputDir: string): void;
-  setName(name: string): void;
-  setHash(hash: string): void;
-  getClientRoutes(): Manifest.RsdoctorManifestClientRoutes[];
-  addClientRoutes(routes: Manifest.RsdoctorManifestClientRoutes[]): void;
-  /** Upload analysis data pieces */
-  protected writePieces(storeData: Common.PlainObject, _options?: SDK.WriteStoreOptionsType): Promise<void>;
-  /** Upload manifest file */
-  protected writeManifest(): Promise<string>;
-  saveManifest(data: Common.PlainObject, options: SDK.WriteStoreOptionsType): Promise<string>;
-  protected writeToFolder(jsonstr: string, dir: string, key: string): Promise<DataWithUrl>;
-  abstract onDataReport(): void | Promise<void>;
-}
+    protected _name: string;
+    protected hash: string;
+    extraConfig: SDK.SDKOptionsType | undefined;
+    readonly root: string;
+    readonly pid: number;
+    readonly hooks: SDK.Hooks;
+    protected _envinfo: SDK.EnvInfo;
+    private _clientRoutes;
+    private _outputDir;
+    diskManifestPath: string;
+    cloudData?: Manifest.RsdoctorManifestWithShardingFiles;
+    constructor({ name, root }: T);
+    get outputDir(): string;
+    get name(): string;
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    setOutputDir(outputDir: string): void;
+    setName(name: string): void;
+    setHash(hash: string): void;
+    getClientRoutes(): Manifest.RsdoctorManifestClientRoutes[];
+    addClientRoutes(routes: Manifest.RsdoctorManifestClientRoutes[]): void;
+    /** Upload analysis data pieces */
+    protected writePieces(storeData: Common.PlainObject, _options?: SDK.WriteStoreOptionsType): Promise<void>;
+    /** Upload manifest file */
+    protected writeManifest(): Promise<string>;
+    saveManifest(data: Common.PlainObject, options: SDK.WriteStoreOptionsType): Promise<string>;
+    protected writeToFolder(jsonstr: string, dir: string, key: string): Promise<DataWithUrl>;
+    abstract onDataReport(): void | Promise<void>;
+}

package/dist/type/sdk/sdk/index.d.ts

@@ -1,2 +1,2 @@
 export * from './webpack';
-export { RsdoctorWebpackSDK as RsdoctorSDK } from './webpack';
+export { RsdoctorWebpackSDK as RsdoctorSDK } from './webpack';

package/dist/type/sdk/sdk/types.d.ts

@@ -1,28 +1,30 @@
 /// <reference types="node" />
 import { SDK } from '@rsdoctor/types';
 export interface DataWithUrl {
-  name: string;
-  files: {
-    path: string;
-    basename: string;
-    content: Buffer;
-  }[] | string;
+    name: string;
+    files: {
+        path: string;
+        basename: string;
+        content: Buffer;
+    }[] | string;
 }
 export interface RsdoctorSDKOptions {
-  name: string;
-  root: string;
+    name: string;
+    root: string;
 }
 /**
  * sdk options for builder.
  */
 export interface RsdoctorBuilderSDK extends RsdoctorSDKOptions {
-  type?: SDK.ToDataType;
-  /**
-   * port for client server
-   */
-  port?: number;
-  noServer?: boolean;
-  config?: SDK.SDKOptionsType;
+    type?: SDK.ToDataType;
+    /**
+     * port for client server
+     */
+    port?: number;
+    noServer?: boolean;
+    config?: SDK.SDKOptionsType;
+}
+export interface RsdoctorWebpackSDKOptions extends RsdoctorBuilderSDK {
+}
+export interface RsdoctorEMOSDKOptions extends RsdoctorSDKOptions {
 }
-export interface RsdoctorWebpackSDKOptions extends RsdoctorBuilderSDK {}
-export interface RsdoctorEMOSDKOptions extends RsdoctorSDKOptions {}

package/dist/type/sdk/sdk/webpack.d.ts

@@ -6,45 +6,45 @@ import { RsdoctorWebpackSDKOptions } from './types';
 import { SDKCore } from './core';
 import { ResourceLoaderData } from '@rsdoctor/types/dist/sdk';
 export declare class RsdoctorWebpackSDK<T extends RsdoctorWebpackSDKOptions = RsdoctorWebpackSDKOptions> extends SDKCore<T> implements SDK.RsdoctorBuilderSDKInstance {
-  server: RsdoctorServer;
-  extraConfig: SDK.SDKOptionsType | undefined;
-  private type;
-  private _summary;
-  private _configs;
-  private _errors;
-  private _loader;
-  private _loaderStart;
-  private _resolver;
-  private _plugin;
-  private _moduleGraph;
-  private _chunkGraph;
-  private _rawSourceMapCache;
-  private _sourceMap;
-  private _packageGraph;
-  private _tileReportHtml;
-  constructor(options: T);
-  bootstrap(): Promise<void>;
-  dispose(): Promise<void>;
-  applyErrorFix(id: number): Promise<void>;
-  clear(): void;
-  clearSourceMapCache(): void;
-  getSourceMap(file: string): Promise<SourceMapConsumer | undefined>;
-  reportSourceMap(data: RawSourceMap): void;
-  reportConfiguration(config: SDK.ConfigData[0]): void;
-  reportError(errors: Error[]): void;
-  reportLoader(data: SDK.LoaderData): void;
-  reportLoaderStartOrEnd(data: ResourceLoaderData): void;
-  reportResolver(data: SDK.ResolverData): void;
-  reportPlugin(data: SDK.PluginData): void;
-  reportModuleGraph(data: ModuleGraph): void;
-  reportPackageGraph(data: PackageGraph): void;
-  reportChunkGraph(data: ChunkGraph): void;
-  reportSummaryData(part: Partial<SDK.SummaryData>): void;
-  reportTileHtml(tileReportHtml: string): void;
-  createPackageGraph(): void;
-  writeStore(options?: SDK.WriteStoreOptionsType): Promise<string>;
-  getStoreData(): SDK.BuilderStoreData;
-  getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
-  getRuleContext(_options: SDK.RuntimeContextOptions): SDK.RuntimeContext;
-  onDataReport(): void | Promise<void>;
-}
+    server: RsdoctorServer;
+    extraConfig: SDK.SDKOptionsType | undefined;
+    private type;
+    private _summary;
+    private _configs;
+    private _errors;
+    private _loader;
+    private _loaderStart;
+    private _resolver;
+    private _plugin;
+    private _moduleGraph;
+    private _chunkGraph;
+    private _rawSourceMapCache;
+    private _sourceMap;
+    private _packageGraph;
+    private _tileReportHtml;
+    constructor(options: T);
+    bootstrap(): Promise<void>;
+    dispose(): Promise<void>;
+    applyErrorFix(id: number): Promise<void>;
+    clear(): void;
+    clearSourceMapCache(): void;
+    getSourceMap(file: string): Promise<SourceMapConsumer | undefined>;
+    reportSourceMap(data: RawSourceMap): void;
+    reportConfiguration(config: SDK.ConfigData[0]): void;
+    reportError(errors: Error[]): void;
+    reportLoader(data: SDK.LoaderData): void;
+    reportLoaderStartOrEnd(data: ResourceLoaderData): void;
+    reportResolver(data: SDK.ResolverData): void;
+    reportPlugin(data: SDK.PluginData): void;
+    reportModuleGraph(data: ModuleGraph): void;
+    reportPackageGraph(data: PackageGraph): void;
+    reportChunkGraph(data: ChunkGraph): void;
+    reportSummaryData(part: Partial<SDK.SummaryData>): void;
+    reportTileHtml(tileReportHtml: string): void;
+    createPackageGraph(): void;
+    writeStore(options?: SDK.WriteStoreOptionsType): Promise<string>;
+    getStoreData(): SDK.BuilderStoreData;
+    getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
+    getRuleContext(_options: SDK.RuntimeContextOptions): SDK.RuntimeContext;
+    onDataReport(): void | Promise<void>;
+}

package/dist/type/sdk/server/apis/alerts.d.ts

@@ -1,5 +1,5 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class AlertsAPI extends BaseAPI {
-  getPackageRelationAlertDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPackageRelationAlertDetails>>;
-}
+    getPackageRelationAlertDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPackageRelationAlertDetails>>;
+}

package/dist/type/sdk/server/apis/base.d.ts

@@ -1,11 +1,11 @@
 import { Data } from '@rsdoctor/utils/common';
 import { Manifest, SDK } from '@rsdoctor/types';
 export declare class BaseAPI implements Manifest.ManifestDataLoader {
-  [key: string | symbol]: any;
-  readonly ctx: SDK.ServerAPI.APIContext;
-  protected dataLoader: Data.APIDataLoader;
-  constructor(sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance);
-  loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
-  loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
-  loadData(key: string): Promise<void>;
-}
+    [key: string | symbol]: any;
+    readonly ctx: SDK.ServerAPI.APIContext;
+    protected dataLoader: Data.APIDataLoader;
+    constructor(sdk: SDK.RsdoctorSDKInstance, server: SDK.RsdoctorServerInstance);
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadData(key: string): Promise<void>;
+}

package/dist/type/sdk/server/apis/bundle-diff.d.ts

@@ -1,6 +1,6 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class BundleDiffAPI extends BaseAPI {
-  getBundleDiffSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetBundleDiffSummary>>;
-  bundleDiffManifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.BundleDiffManifest>>;
-}
+    getBundleDiffSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetBundleDiffSummary>>;
+    bundleDiffManifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.BundleDiffManifest>>;
+}

package/dist/type/sdk/server/apis/data.d.ts

@@ -1,6 +1,6 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class DataAPI extends BaseAPI {
-  loadDataByKey(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.LoadDataByKey>>;
-  sendMessageToClient(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.SendAPIDataToClient>>;
-}
+    loadDataByKey(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.LoadDataByKey>>;
+    sendMessageToClient(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.SendAPIDataToClient>>;
+}

package/dist/type/sdk/server/apis/fs.d.ts

@@ -1,5 +1,5 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class FileSystemAPI extends BaseAPI {
-  applyErrorFix(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ApplyErrorFix>>;
-}
+    applyErrorFix(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ApplyErrorFix>>;
+}

package/dist/type/sdk/server/apis/graph.d.ts

@@ -1,12 +1,12 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class GraphAPI extends BaseAPI {
-  getAssetsSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetsSummary>>;
-  getModuleGraphForAsset(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetDetails>>;
-  getChunksByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetChunksByModuleId>>;
-  getModuleDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleDetails>>;
-  getDependencyByResolvedRequest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModulesByModuleIds>>;
-  getModuleCodeByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleId>>;
-  getModuleCodeByModuleIds(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleIds>>;
-  getEntryModulesSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetEntryPoints>>;
-}
+    getAssetsSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetsSummary>>;
+    getModuleGraphForAsset(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetAssetDetails>>;
+    getChunksByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetChunksByModuleId>>;
+    getModuleDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleDetails>>;
+    getDependencyByResolvedRequest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModulesByModuleIds>>;
+    getModuleCodeByModuleId(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleId>>;
+    getModuleCodeByModuleIds(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetModuleCodeByModuleIds>>;
+    getEntryModulesSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetEntryPoints>>;
+}

package/dist/type/sdk/server/apis/index.d.ts

@@ -6,4 +6,4 @@ export * from './graph';
 export * from './plugin';
 export * from './project';
 export * from './renderer';
-export * from './resolver';
+export * from './resolver';

package/dist/type/sdk/server/apis/loader.d.ts

@@ -1,16 +1,16 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class LoaderAPI extends BaseAPI {
-  /** report loader data api */
-  reportLoader(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
-  /** report sourcemap data api */
-  reportSourceMap(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
-  getLoaderNames(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderNames>>;
-  getLoaderChartData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderChartData>>;
-  getLoaderFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileTree>>;
-  getLoaderFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileDetails>>;
-  getLoaderFolderStatistics(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFolderStatistics>>;
-  getLoaderFileFirstInput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileFirstInput>>;
-  getLoaderFileInputAndOutput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileInputAndOutput>>;
-  getTileReportHtml(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetTileReportHtml>>;
-}
+    /** report loader data api */
+    reportLoader(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
+    /** report sourcemap data api */
+    reportSourceMap(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.ReportLoader>>;
+    getLoaderNames(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderNames>>;
+    getLoaderChartData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderChartData>>;
+    getLoaderFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileTree>>;
+    getLoaderFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileDetails>>;
+    getLoaderFolderStatistics(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFolderStatistics>>;
+    getLoaderFileFirstInput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileFirstInput>>;
+    getLoaderFileInputAndOutput(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetLoaderFileInputAndOutput>>;
+    getTileReportHtml(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetTileReportHtml>>;
+}

package/dist/type/sdk/server/apis/plugin.d.ts

@@ -1,6 +1,6 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class PluginAPI extends BaseAPI {
-  getPluginSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginSummary>>;
-  getPluginData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginData>>;
-}
+    getPluginSummary(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginSummary>>;
+    getPluginData(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPluginData>>;
+}

package/dist/type/sdk/server/apis/project.d.ts

@@ -1,8 +1,8 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class ProjectAPI extends BaseAPI {
-  env(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Env>>;
-  manifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Manifest>>;
-  getProjectInfo(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetProjectInfo>>;
-  getClientRoutes(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetClientRoutes>>;
-}
+    env(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Env>>;
+    manifest(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.Manifest>>;
+    getProjectInfo(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetProjectInfo>>;
+    getClientRoutes(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetClientRoutes>>;
+}

package/dist/type/sdk/server/apis/renderer.d.ts

@@ -1,7 +1,7 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class RendererAPI extends BaseAPI {
-  private isClientServed;
-  /** sdk manifest api */
-  entryHtml(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.EntryHtml>>;
-}
+    private isClientServed;
+    /** sdk manifest api */
+    entryHtml(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.EntryHtml>>;
+}

package/dist/type/sdk/server/apis/resolver.d.ts

@@ -1,6 +1,6 @@
 import { SDK } from '@rsdoctor/types';
 import { BaseAPI } from './base';
 export declare class ResolverAPI extends BaseAPI {
-  getResolverFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileTree>>;
-  getResolverFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileDetails>>;
-}
+    getResolverFileTree(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileTree>>;
+    getResolverFileDetails(): Promise<SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetResolverFileDetails>>;
+}

package/dist/type/sdk/server/fakeServer.d.ts

@@ -1,7 +1,7 @@
 import { SDK } from '@rsdoctor/types';
 import { RsdoctorServer } from '.';
 export declare class RsdoctorFakeServer extends RsdoctorServer {
-  protected sdk: SDK.RsdoctorBuilderSDKInstance;
-  constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number);
-  openClientPage(): Promise<void>;
-}
+    protected sdk: SDK.RsdoctorBuilderSDKInstance;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number);
+    openClientPage(): Promise<void>;
+}

package/dist/type/sdk/server/index.d.ts

@@ -2,26 +2,27 @@
 import { Common, SDK, Thirdparty, Client } from '@rsdoctor/types';
 export * from './utils';
 export declare class RsdoctorServer implements SDK.RsdoctorServerInstance {
-  protected sdk: SDK.RsdoctorBuilderSDKInstance;
-  private _server;
-  port: number;
-  private _socket?;
-  private disposed;
-  private _router;
-  constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number);
-  get app(): SDK.RsdoctorServerInstance['app'];
-  get origin(): string;
-  get socketUrl(): string;
-  bootstrap(): Promise<void>;
-  protected wrapNextHandleFunction(method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): Thirdparty.connect.NextHandleFunction;
-  proxy(api: SDK.ServerAPI.API, method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): void;
-  get: SDK.RsdoctorServerInstance['get'];
-  post: SDK.RsdoctorServerInstance['post'];
-  getClientUrl(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): string;
-  getClientUrl(route?: 'homepage'): string;
-  openClientPage(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): Promise<void>;
-  openClientPage(route?: 'homepage'): Promise<void>;
-  sendAPIDataToClient<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
-  broadcast(): Promise<void>;
-  dispose: () => Promise<void>;
-}
+    protected sdk: SDK.RsdoctorBuilderSDKInstance;
+    private _server;
+    port: number;
+    private _socket?;
+    private disposed;
+    private _router;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, port?: number);
+    get app(): SDK.RsdoctorServerInstance['app'];
+    get host(): string;
+    get origin(): string;
+    get socketUrl(): string;
+    bootstrap(): Promise<void>;
+    protected wrapNextHandleFunction(method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): Thirdparty.connect.NextHandleFunction;
+    proxy(api: SDK.ServerAPI.API, method: 'GET' | 'POST', cb: (...args: Parameters<Thirdparty.connect.NextHandleFunction>) => Common.PlainObject | string): void;
+    get: SDK.RsdoctorServerInstance['get'];
+    post: SDK.RsdoctorServerInstance['post'];
+    getClientUrl(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): string;
+    getClientUrl(route?: 'homepage'): string;
+    openClientPage(route: Client.RsdoctorClientRoutes, baselineUrl: string, currentUrl: string): Promise<void>;
+    openClientPage(route?: 'homepage'): Promise<void>;
+    sendAPIDataToClient<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
+    broadcast(): Promise<void>;
+    dispose: () => Promise<void>;
+}

package/dist/type/sdk/server/router.d.ts

@@ -3,23 +3,23 @@ import type { ServerResponse } from 'http';
 import { Common, SDK, Thirdparty } from '@rsdoctor/types';
 import { BaseAPI } from './apis/base';
 interface RouterOptions {
-  apis: Common.Constructor<typeof BaseAPI>[];
-  sdk: SDK.RsdoctorBuilderSDKInstance;
-  server: SDK.RsdoctorServerInstance;
+    apis: Common.Constructor<typeof BaseAPI>[];
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+    server: SDK.RsdoctorServerInstance;
 }
 export declare class Router {
-  protected options: RouterOptions;
-  static routes: {
-    /**
-     * - `key` is the constuctor of object which used to match the API class
-     */
-    get: Map<Function, [apiKey: PropertyKey, pathname: string][]>;
-    post: Map<Function, [apiKey: PropertyKey, pathname: string][]>;
-  };
-  static get(pathname: string): MethodDecorator;
-  static post(pathname: string): MethodDecorator;
-  constructor(options: RouterOptions);
-  setup(): Promise<void>;
-  wrapAPIFunction<T extends BaseAPI>(api: T, key: PropertyKey): (req: Thirdparty.connect.IncomingMessage, res: ServerResponse) => Promise<any>;
+    protected options: RouterOptions;
+    static routes: {
+        /**
+         * - `key` is the constuctor of object which used to match the API class
+         */
+        get: Map<Function, [apiKey: PropertyKey, pathname: string][]>;
+        post: Map<Function, [apiKey: PropertyKey, pathname: string][]>;
+    };
+    static get(pathname: string): MethodDecorator;
+    static post(pathname: string): MethodDecorator;
+    constructor(options: RouterOptions);
+    setup(): Promise<void>;
+    wrapAPIFunction<T extends BaseAPI>(api: T, key: PropertyKey): (req: Thirdparty.connect.IncomingMessage, res: ServerResponse) => Promise<any>;
 }
-export {};
+export {};

package/dist/type/sdk/server/socket/api.d.ts

@@ -1,15 +1,15 @@
 import { Data } from '@rsdoctor/utils/common';
 import { Manifest, SDK } from '@rsdoctor/types';
 interface SocketAPILoaderOptions {
-  sdk: SDK.RsdoctorBuilderSDKInstance;
+    sdk: SDK.RsdoctorBuilderSDKInstance;
 }
 export declare class SocketAPILoader implements Manifest.ManifestDataLoader {
-  protected options: SocketAPILoaderOptions;
-  protected dataLoader: Data.APIDataLoader;
-  constructor(options: SocketAPILoaderOptions);
-  loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
-  loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
-  loadData(key: string): Promise<void>;
-  get loadAPIData(): <T extends SDK.ServerAPI.API, B extends import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResquestBodyTypes, T, void> = import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResquestBodyTypes, T, void>, R extends import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void> = import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void>>(...args: B extends void ? [api: T] : [api: T, body: B]) => Promise<import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void>>;
+    protected options: SocketAPILoaderOptions;
+    protected dataLoader: Data.APIDataLoader;
+    constructor(options: SocketAPILoaderOptions);
+    loadManifest(): Promise<Manifest.RsdoctorManifestWithShardingFiles>;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    loadData(key: string): Promise<void>;
+    get loadAPIData(): <T extends SDK.ServerAPI.API, B extends import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResquestBodyTypes, T, void> = import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResquestBodyTypes, T, void>, R extends import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void> = import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void>>(...args: B extends void ? [api: T] : [api: T, body: B]) => Promise<import("@rsdoctor/types/dist/common").Get<SDK.ServerAPI.ResponseTypes, T, void>>;
 }
-export {};
+export {};

package/dist/type/sdk/server/socket/index.d.ts

@@ -5,24 +5,24 @@ import type { Server } from 'http';
 import { Server as SocketServer, ServerOptions as SocketServerOptions, Socket as SocketType } from 'socket.io';
 import { SocketAPILoader } from './api';
 interface SocketOptions {
-  sdk: SDK.RsdoctorBuilderSDKInstance;
-  server: Server;
-  port: number;
-  socketOptions?: SocketServerOptions;
+    sdk: SDK.RsdoctorBuilderSDKInstance;
+    server: Server;
+    port: number;
+    socketOptions?: SocketServerOptions;
 }
 export declare class Socket {
-  protected options: SocketOptions;
-  protected io: SocketServer;
-  protected loader: SocketAPILoader;
-  protected map: Map<SDK.ServerAPI.API, (Common.PlainObject | null)[]>;
-  constructor(options: SocketOptions);
-  bootstrap(): void;
-  protected setupSocket(socket: SocketType): void;
-  protected saveRequestToMap<T extends SDK.ServerAPI.API>(api: T, body?: SDK.ServerAPI.InferRequestBodyType<T, null> | null): void;
-  protected getAPIResponse<T extends SDK.ServerAPI.API>(api: T, body: SDK.ServerAPI.InferRequestBodyType<T>): Promise<SDK.ServerAPI.SocketResponseType<SDK.ServerAPI.API>>;
-  protected timer: NodeJS.Immediate | undefined;
-  broadcast(): Promise<void>;
-  sendAPIData<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
-  dispose(): void;
+    protected options: SocketOptions;
+    protected io: SocketServer;
+    protected loader: SocketAPILoader;
+    protected map: Map<SDK.ServerAPI.API, (Common.PlainObject | null)[]>;
+    constructor(options: SocketOptions);
+    bootstrap(): void;
+    protected setupSocket(socket: SocketType): void;
+    protected saveRequestToMap<T extends SDK.ServerAPI.API>(api: T, body?: SDK.ServerAPI.InferRequestBodyType<T, null> | null): void;
+    protected getAPIResponse<T extends SDK.ServerAPI.API>(api: T, body: SDK.ServerAPI.InferRequestBodyType<T>): Promise<SDK.ServerAPI.SocketResponseType<SDK.ServerAPI.API>>;
+    protected timer: NodeJS.Immediate | undefined;
+    broadcast(): Promise<void>;
+    sendAPIData<T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(api: T, msg: SDK.ServerAPI.SocketResponseType<T>): void;
+    dispose(): void;
 }
-export {};
+export {};

package/dist/type/sdk/server/utils.d.ts

@@ -1,5 +1,5 @@
 import { SDK } from '@rsdoctor/types';
 export declare function getDataByPagination<T>(data: T[], pagination: SDK.ServerAPI.PaginationRequest): {
-  data: T[];
-  pagination: SDK.ServerAPI.PaginationResponse;
-};
+    data: T[];
+    pagination: SDK.ServerAPI.PaginationResponse;
+};

package/dist/type/sdk/utils/constant.d.ts

@@ -1 +1 @@
-export declare const CLOUD_DIR: string;
+export declare const CLOUD_DIR: string;

package/dist/type/sdk/utils/index.d.ts

@@ -1,2 +1,2 @@
 export * from './constant';
-export * from './upload';
+export * from './upload';

package/dist/type/sdk/utils/openBrowser.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Reads the BROWSER environment variable and decides what to do with it.
+ */
+export declare function openBrowser(url: string): Promise<boolean>;

package/dist/type/sdk/utils/upload.d.ts

@@ -1,2 +1,2 @@
 import { DataWithUrl } from '../sdk/types';
-export declare const transformDataUrls: (d: DataWithUrl[]) => Record<string, string[] | string>;
+export declare const transformDataUrls: (d: DataWithUrl[]) => Record<string, string[] | string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -11,7 +11,8 @@
   "module": "dist/esm/index.js",
   "types": "dist/type/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "static"
   ],
   "dependencies": {
     "body-parser": "1.20.1",
@@ -24,10 +25,10 @@
     "socket.io": "4.7.2",
     "source-map": "^0.7.4",
     "tapable": "2.2.1",
-    "@rsdoctor/client": "0.1.0",
-    "@rsdoctor/graph": "0.1.0",
-    "@rsdoctor/utils": "0.1.0",
-    "@rsdoctor/types": "0.1.0"
+    "@rsdoctor/client": "0.1.2",
+    "@rsdoctor/graph": "0.1.2",
+    "@rsdoctor/types": "0.1.2",
+    "@rsdoctor/utils": "0.1.2"
   },
   "devDependencies": {
     "@types/body-parser": "1.19.2",

package/static/openChrome.applescript

@@ -0,0 +1,95 @@
+(*
+Copyright (c) 2015-present, Facebook, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file at
+https://github.com/facebookincubator/create-react-app/blob/master/LICENSE
+*)
+
+property targetTab: null
+property targetTabIndex: -1
+property targetWindow: null
+property theProgram: "Google Chrome"
+
+on run argv
+  set theURL to item 1 of argv
+
+  -- Allow requested program to be optional,
+  -- default to Google Chrome
+  if (count of argv) > 1 then
+    set theProgram to item 2 of argv
+  end if
+
+  using terms from application "Google Chrome"
+    tell application theProgram
+
+      if (count every window) = 0 then
+        make new window
+      end if
+
+      -- 1: Looking for tab running debugger
+      -- then, Reload debugging tab if found
+      -- then return
+      set found to my lookupTabWithUrl(theURL)
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        tell targetTab to reload
+        tell targetWindow to activate
+        set index of targetWindow to 1
+        return
+      end if
+
+      -- 2: Looking for Empty tab
+      -- In case debugging tab was not found
+      -- We try to find an empty tab instead
+      set found to my lookupTabWithUrl("chrome://newtab/")
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        set URL of targetTab to theURL
+        tell targetWindow to activate
+        return
+      end if
+
+      -- 3: Create new tab
+      -- both debugging and empty tab were not found
+      -- make a new tab with url
+      tell window 1
+        activate
+        make new tab with properties {URL:theURL}
+      end tell
+    end tell
+  end using terms from
+end run
+
+-- Function:
+-- Lookup tab with given url
+-- if found, store tab, index, and window in properties
+-- (properties were declared on top of file)
+on lookupTabWithUrl(lookupUrl)
+  using terms from application "Google Chrome"
+    tell application theProgram
+      -- Find a tab with the given url
+      set found to false
+      set theTabIndex to -1
+      repeat with theWindow in every window
+        set theTabIndex to 0
+        repeat with theTab in every tab of theWindow
+          set theTabIndex to theTabIndex + 1
+          if (theTab's URL as string) contains lookupUrl then
+            -- assign tab, tab index, and window to properties
+            set targetTab to theTab
+            set targetTabIndex to theTabIndex
+            set targetWindow to theWindow
+            set found to true
+            exit repeat
+          end if
+        end repeat
+
+        if found then
+          exit repeat
+        end if
+      end repeat
+    end tell
+  end using terms from
+  return found
+end lookupTabWithUrl