@rsdoctor/sdk 0.0.2-beta.0

package/dist/esm/sdk/multiple/slave.js

@@ -0,0 +1,64 @@
+import path from "path";
+import { DoctorWebpackSDK } from "../sdk";
+import { DoctorSlaveServer } from "./server";
+let id = 1;
+class DoctorSlaveSDK extends DoctorWebpackSDK {
+  constructor({ name, stage, controller, extraConfig }) {
+    super({ name, root: controller.root });
+    const lastSdk = controller.getLastSdk();
+    const port = lastSdk ? lastSdk.server.port + 1 : this.server.port;
+    this.id = id++;
+    this.stage = typeof stage === "number" ? stage : 1;
+    this.extraConfig = extraConfig;
+    this.parent = controller;
+    this.server = new DoctorSlaveServer(this, port);
+    this.setName(name);
+    this.clearSwitch();
+  }
+  clearSwitch() {
+    this.uploadPieces = new Promise((resolve) => {
+      this.finishUploadPieceSwitch = resolve;
+    });
+  }
+  get isMaster() {
+    return this.parent.master === this;
+  }
+  async writePieces() {
+    const { name, parent, isMaster, outputDir, finishUploadPieceSwitch } = this;
+    this.setOutputDir(
+      isMaster ? outputDir : path.join(
+        parent.master.outputDir,
+        ".slaves",
+        name.replace(/\s+/g, "-")
+      )
+    );
+    await super.writePieces(this.getStoreData());
+    finishUploadPieceSwitch?.();
+  }
+  async writeManifest() {
+    const { parent, cloudData } = this;
+    await Promise.all(this.parent.slaves.map((item) => item.uploadPieces));
+    if (cloudData) {
+      cloudData.name = this.name;
+      cloudData.series = parent.getSeriesData();
+    }
+    const result = await super.writeManifest();
+    this.clearSwitch();
+    return result;
+  }
+  getSeriesData(serverUrl = false) {
+    return this.parent.getSeriesData(serverUrl);
+  }
+  setName(name) {
+    this._name = this.parent.hasName(name) ? `${name}-${id}` : name;
+  }
+  getManifestData() {
+    const data = super.getManifestData();
+    data.name = this.name;
+    data.series = this.getSeriesData(true);
+    return data;
+  }
+}
+export {
+  DoctorSlaveSDK
+};

package/dist/esm/sdk/sdk/core.js

@@ -0,0 +1,151 @@
+import { Constants, Manifest } from "@rsdoctor/types";
+import { File, Json, EnvInfo } from "@rsdoctor/utils/build";
+import { Algorithm } from "@rsdoctor/utils/common";
+import path from "path";
+import { createHash } from "crypto";
+import process from "process";
+import { AsyncSeriesHook } from "tapable";
+import { debug } from "@rsdoctor/utils/logger";
+import { transformDataUrls } from "../utils";
+class SDKCore {
+  constructor({ name, root }) {
+    this.hooks = {
+      afterSaveManifest: new AsyncSeriesHook(["result"])
+    };
+    this._envinfo = {};
+    this._clientRoutes = /* @__PURE__ */ new Set([
+      Manifest.DoctorManifestClientRoutes.Overall
+    ]);
+    this.diskManifestPath = "";
+    this._name = name;
+    this.root = root;
+    this.pid = process.pid;
+    this._outputDir = path.join(this.root, Constants.DoctorOutputFolder);
+  }
+  get outputDir() {
+    return this._outputDir;
+  }
+  get name() {
+    return this._name;
+  }
+  async bootstrap() {
+    const [cpu, memory, nodeVersion, yarnVersion, npmVersion, pnpmVersion] = await Promise.all([
+      EnvInfo.getCPUInfo(),
+      EnvInfo.getMemoryInfo(),
+      EnvInfo.getNodeVersion(),
+      EnvInfo.getYarnVersion(),
+      EnvInfo.getNpmVersion(),
+      EnvInfo.getGlobalNpmPackageVersion("pnpm")
+    ]);
+    this._envinfo = {
+      ...this._envinfo,
+      cpu,
+      memory,
+      nodeVersion,
+      yarnVersion,
+      npmVersion,
+      pnpmVersion
+    };
+    const hash = createHash("md5").update(
+      [this.name, this.root, JSON.stringify(this._envinfo), Date.now()].join(
+        "_"
+      )
+    ).digest("hex");
+    this.setHash(hash);
+  }
+  async dispose() {
+  }
+  setOutputDir(outputDir) {
+    this._outputDir = outputDir;
+  }
+  setName(name) {
+    this._name = name;
+  }
+  setHash(hash) {
+    this.hash = hash;
+  }
+  getClientRoutes() {
+    return [...this._clientRoutes];
+  }
+  addClientRoutes(routes) {
+    routes.forEach((route) => {
+      this._clientRoutes.add(route);
+    });
+    this.onDataReport();
+  }
+  /** Upload analysis data pieces */
+  async writePieces(storeData, _options) {
+    const { outputDir } = this;
+    const manifest = path.resolve(outputDir, Constants.DoctorOutputManifest);
+    this.diskManifestPath = manifest;
+    await File.fse.ensureDir(outputDir);
+    const dataUrls = await Promise.all(
+      Object.keys(storeData).map(async (key) => {
+        const data = storeData[key];
+        if (typeof data !== "object") {
+          return {
+            name: key,
+            files: data
+          };
+        }
+        const jsonstr = await (async () => {
+          try {
+            return JSON.stringify(data);
+          } catch (error) {
+            return Json.stringify(data);
+          }
+        })();
+        return this.writeToFolder(jsonstr, outputDir, key);
+      })
+    );
+    debug(
+      () => `SDKCore.writePieces extraConfig: ${JSON.stringify(this.extraConfig)}`,
+      "[SDKCore.writePieces]"
+    );
+    this.cloudData = {
+      client: {
+        enableRoutes: this.getClientRoutes()
+      },
+      data: transformDataUrls(dataUrls)
+    };
+  }
+  /** Upload manifest file */
+  async writeManifest() {
+    const { cloudData: data, diskManifestPath } = this;
+    const dataStr = JSON.stringify(data, null, 2);
+    debug(
+      () => `SDKCore.writeManifest extraConfig: ${this.extraConfig}`,
+      "[SDKCore.writeManifest]"
+    );
+    await Promise.all([File.fse.writeFile(diskManifestPath, dataStr)]);
+    return diskManifestPath;
+  }
+  async saveManifest(data, options) {
+    await this.writePieces(data, options);
+    const manifestDiskPath = await this.writeManifest();
+    await this.hooks.afterSaveManifest.promise({
+      manifestWithShardingFiles: this.cloudData,
+      manifestDiskPath
+    });
+    return manifestDiskPath;
+  }
+  writeToFolder(jsonstr, dir, key) {
+    const sharding = new File.FileSharding(Algorithm.compressText(jsonstr));
+    const folder = path.resolve(dir, key);
+    const writer = sharding.writeStringToFolder(folder);
+    return writer.then((item) => {
+      const res = {
+        name: key,
+        files: item.map((el) => ({
+          path: path.resolve(folder, el.filename),
+          basename: el.filename,
+          content: el.content
+        }))
+      };
+      return res;
+    });
+  }
+}
+export {
+  SDKCore
+};

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

@@ -0,0 +1,5 @@
+export * from "./webpack";
+import { DoctorWebpackSDK } from "./webpack";
+export {
+  DoctorWebpackSDK as DoctorSDK
+};

package/dist/esm/sdk/sdk/webpack.js

@@ -0,0 +1,349 @@
+import { DevToolError } from "@rsdoctor/utils/error";
+import { SDK } from "@rsdoctor/types";
+import { File } from "@rsdoctor/utils/build";
+import { SourceMapConsumer } from "source-map";
+import { ModuleGraph, ChunkGraph, PackageGraph } from "@rsdoctor/graph";
+import { debug } from "@rsdoctor/utils/logger";
+import { DoctorServer } from "../server";
+import { DoctorFakeServer } from "../server/fakeServer";
+import { SDKCore } from "./core";
+class DoctorWebpackSDK extends SDKCore {
+  constructor(options) {
+    super(options);
+    this._summary = { costs: [] };
+    this._configs = [];
+    this._errors = [];
+    this._loader = [];
+    this._resolver = [];
+    this._plugin = {};
+    this._moduleGraph = new ModuleGraph();
+    this._chunkGraph = new ChunkGraph();
+    this._rawSourceMapCache = /* @__PURE__ */ new Map();
+    this._sourceMap = /* @__PURE__ */ new Map();
+    this.server = options.noServer ? new DoctorFakeServer(this, void 0) : new DoctorServer(this, options.port);
+    this.type = options.type || SDK.ToDataType.Normal;
+    this.extraConfig = options.config;
+  }
+  async bootstrap() {
+    debug(() => `${Date.now()}`, "[DoctorWebpackSDK][bootstrap start]");
+    this.server && await this.server.bootstrap();
+    await super.bootstrap();
+    debug(
+      () => `${Date.now()} ${this.server.origin}`,
+      "[DoctorWebpackSDK][bootstrap end]"
+    );
+  }
+  async dispose() {
+    debug(() => `${Date.now()}`, "[DoctorWebpackSDK][dispose start]");
+    this.server && await this.server.dispose();
+    await super.dispose();
+    debug(() => `${Date.now()}`, "[DoctorWebpackSDK][dispose end]");
+  }
+  async applyErrorFix(id) {
+    const { _errors: errors } = this;
+    const error = errors.find((err) => err.id === id);
+    if (!error || !error.path || !error.fixData || error.fixData.isFixed) {
+      return;
+    }
+    const { path: filePath, fixData } = error;
+    const sameFileErrors = errors.filter(
+      (item) => item.path === filePath && item !== error
+    );
+    let content = (await File.fse.readFile(filePath, "utf-8")).toString();
+    const startTxt = content.substring(0, fixData.start);
+    const endTxt = content.substring(fixData.end, content.length);
+    const offset = (fixData.newText ?? "").length - (fixData.end - fixData.start);
+    content = startTxt + fixData.newText + endTxt;
+    for (const other of sameFileErrors) {
+      const { fixData: otherFixData } = other;
+      if (!otherFixData) {
+        continue;
+      }
+      if (otherFixData.start >= fixData.end) {
+        otherFixData.start += offset;
+        otherFixData.end += offset;
+      }
+    }
+    await File.fse.writeFile(filePath, content);
+  }
+  clear() {
+    this._errors = [];
+    this._loader = [];
+    this._resolver = [];
+    this._plugin = {};
+    this._moduleGraph = new ModuleGraph();
+    this._chunkGraph = new ChunkGraph();
+  }
+  clearSourceMapCache() {
+    this._rawSourceMapCache = /* @__PURE__ */ new Map();
+    this._sourceMap = /* @__PURE__ */ new Map();
+  }
+  async getSourceMap(file) {
+    const { _sourceMap: sourceMap, _rawSourceMapCache: rawMap } = this;
+    if (sourceMap.has(file)) {
+      return sourceMap.get(file);
+    }
+    const rawData = rawMap.get(file);
+    if (!rawData || rawData.version < 0 || !rawData.sourcesContent?.[0] || !rawData.mappings) {
+      return Promise.resolve(void 0);
+    }
+    try {
+      const result = await new SourceMapConsumer(rawData);
+      sourceMap.set(file, result);
+      return result;
+    } catch (e) {
+      return Promise.resolve(void 0);
+    }
+  }
+  reportSourceMap(data) {
+    this._rawSourceMapCache.set(data.file, data);
+  }
+  reportConfiguration(config) {
+    this._configs.push(config);
+    this.onDataReport();
+  }
+  reportError(errors) {
+    errors.forEach((item) => {
+      this._errors.push(
+        DevToolError.from(item, {
+          code: this.name
+        })
+      );
+    });
+    this.onDataReport();
+  }
+  reportLoader(data) {
+    data.forEach((item) => {
+      let match = this._loader.find(
+        (e) => e.resource.path === item.resource.path
+      );
+      if (match) {
+        match.loaders.push(...item.loaders);
+      } else {
+        match = item;
+        this._loader.push(item);
+      }
+      match.loaders.sort((a, b) => {
+        if (a.startAt !== b.startAt) {
+          return a.startAt - b.startAt;
+        }
+        if (a.isPitch) {
+          if (b.isPitch) {
+            return a.loaderIndex - b.loaderIndex;
+          }
+          return -1;
+        }
+        if (b.isPitch) {
+          return 1;
+        }
+        return b.loaderIndex - a.loaderIndex;
+      });
+    });
+    this.onDataReport();
+  }
+  reportResolver(data) {
+    data.forEach((item) => this._resolver.push(item));
+    this.onDataReport();
+  }
+  reportPlugin(data) {
+    Object.keys(data).forEach((hook) => {
+      if (!this._plugin[hook]) {
+        this._plugin[hook] = data[hook];
+      } else {
+        data[hook].forEach((item) => {
+          this._plugin[hook].push(item);
+        });
+      }
+    });
+    this.onDataReport();
+  }
+  reportModuleGraph(data) {
+    debug(() => `data size: ${data.size()}`, "[SDK.reportModuleGraph][start]");
+    this._moduleGraph.fromInstance(data);
+    this.createPackageGraph();
+    this.onDataReport();
+    debug(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK reportModuleGraph][end]"
+    );
+  }
+  reportPackageGraph(data) {
+    debug(() => "[SDK.reportPackageGraph][start]");
+    if (!this._packageGraph) {
+      this._packageGraph = data;
+    }
+    this.onDataReport();
+    debug(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK reportPackageGraph][end]"
+    );
+  }
+  reportChunkGraph(data) {
+    this._chunkGraph.addAsset(...data.getAssets());
+    this._chunkGraph.addChunk(...data.getChunks());
+    this._chunkGraph.addEntryPoint(...data.getEntryPoints());
+    this.onDataReport();
+  }
+  reportSummaryData(part) {
+    const keys = ["costs"];
+    for (const key of keys) {
+      const v = part[key];
+      if (!v)
+        continue;
+      if (typeof v === "object") {
+        if (Array.isArray(v)) {
+          this._summary[key] = [
+            ...this._summary[key] || [],
+            ...v
+          ];
+        } else {
+          this._summary[key] = {
+            ...this._summary[key] || {},
+            ...v
+          };
+        }
+      } else {
+        this._summary[key] = v;
+      }
+    }
+    this.onDataReport();
+  }
+  reportTileHtml(tileReportHtml) {
+    this._tileReportHtml = tileReportHtml;
+  }
+  createPackageGraph() {
+    debug(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK.createPackageGraph][start]"
+    );
+    if (!this._packageGraph) {
+      const pkgGraph = PackageGraph.fromModuleGraph(
+        this._moduleGraph,
+        this.root,
+        (path) => {
+          try {
+            const exists = File.fse.existsSync(path);
+            if (exists) {
+              debug(
+                () => `sdk.PackageGraph package.json exists: ${exists}, path: ${path}`,
+                "[SDK.createPackageGraph][load]"
+              );
+              return File.fse.readJSONSync(path);
+            }
+          } catch (error) {
+            const { message, stack } = error;
+            debug(
+              () => `sdk.createPackageGraph error, path: ${path}, error message: ${stack || message}`,
+              "[SDK.createPackageGraph][error]"
+            );
+          }
+        }
+      );
+      this._packageGraph = pkgGraph;
+      debug(
+        () => `sdk._packageGraph packages: ${this._packageGraph.getPackages().length}`,
+        "[SDK.createPackageGraph][end]"
+      );
+    }
+  }
+  writeStore(options) {
+    debug(() => `sdk.writeStore has run.`, "[SDK.writeStore][end]");
+    return this.saveManifest(this.getStoreData(), options || {});
+  }
+  getStoreData() {
+    const ctx = this;
+    return {
+      get hash() {
+        return ctx.hash;
+      },
+      get root() {
+        return ctx.root;
+      },
+      get envinfo() {
+        return ctx._envinfo;
+      },
+      get pid() {
+        return ctx.pid;
+      },
+      get errors() {
+        return ctx._errors.map((err) => err.toData());
+      },
+      get configs() {
+        return ctx._configs.slice();
+      },
+      get summary() {
+        return { ...ctx._summary };
+      },
+      get resolver() {
+        return ctx._resolver.slice();
+      },
+      get loader() {
+        return ctx._loader.slice();
+      },
+      get moduleGraph() {
+        return ctx._moduleGraph.toData({
+          contextPath: ctx._configs?.[0]?.config?.context || ""
+        });
+      },
+      get chunkGraph() {
+        return ctx._chunkGraph.toData(ctx.type);
+      },
+      get moduleCodeMap() {
+        return ctx._moduleGraph.toCodeData(ctx.type);
+      },
+      get plugin() {
+        return { ...ctx._plugin };
+      },
+      get packageGraph() {
+        return ctx._packageGraph ? ctx._packageGraph.toData() : {
+          packages: [],
+          dependencies: []
+        };
+      },
+      get otherReports() {
+        return { tileReportHtml: ctx._tileReportHtml || "" };
+      }
+    };
+  }
+  getManifestData() {
+    const dataValue = this.getStoreData();
+    const data = {
+      client: {
+        enableRoutes: this.getClientRoutes()
+      },
+      data: Object.keys(dataValue).reduce((t, e) => {
+        const _e = e;
+        if (dataValue[_e] && typeof dataValue[_e] === "object") {
+          t[e] = [
+            `${this.server.origin}${SDK.ServerAPI.API.LoadDataByKey}/${e}`
+          ];
+        } else {
+          t[e] = dataValue[_e];
+        }
+        return t;
+      }, {}),
+      __LOCAL__SERVER__: true,
+      __SOCKET__URL__: this.server.socketUrl
+    };
+    return data;
+  }
+  getRuleContext(_options) {
+    this.createPackageGraph();
+    return {
+      root: this.root,
+      errors: this._errors.slice(),
+      configs: this._configs.slice(),
+      moduleGraph: this._moduleGraph,
+      chunkGraph: this._chunkGraph,
+      packageGraph: this._packageGraph,
+      loader: this._loader.slice(),
+      otherReports: { tileReportHtml: this._tileReportHtml || "" }
+    };
+  }
+  onDataReport() {
+    this.server.broadcast();
+  }
+}
+export {
+  DoctorWebpackSDK
+};

package/dist/esm/sdk/server/apis/alerts.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class AlertsAPI extends BaseAPI {
+  async getPackageRelationAlertDetails() {
+    const { req } = this.ctx;
+    const { id, target } = req.body;
+    return this.dataLoader.loadAPI(
+      SDK.ServerAPI.API.GetPackageRelationAlertDetails,
+      { id, target }
+    );
+  }
+}
+__decorateClass([
+  Router.post(SDK.ServerAPI.API.GetPackageRelationAlertDetails)
+], AlertsAPI.prototype, "getPackageRelationAlertDetails", 1);
+export {
+  AlertsAPI
+};

package/dist/esm/sdk/server/apis/base.js

@@ -0,0 +1,22 @@
+import { Data } from "@rsdoctor/utils/common";
+class BaseAPI {
+  constructor(sdk, server) {
+    this.ctx = { sdk, server };
+    this.dataLoader = new Data.APIDataLoader(this);
+  }
+  async loadManifest() {
+    return this.ctx.sdk.getManifestData();
+  }
+  async loadData(key) {
+    const data = this.ctx.sdk.getStoreData();
+    const sep = ".";
+    let res = data[key];
+    if (key.includes(sep)) {
+      res = key.split(sep).reduce((t, k) => t[k], data);
+    }
+    return res;
+  }
+}
+export {
+  BaseAPI
+};

package/dist/esm/sdk/server/apis/bundle-diff.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { SDK } from "@rsdoctor/types";
+import { BaseAPI } from "./base";
+import { Router } from "../router";
+class BundleDiffAPI extends BaseAPI {
+  async getBundleDiffSummary() {
+    const { sdk } = this.ctx;
+    const {
+      root,
+      hash,
+      errors,
+      chunkGraph,
+      moduleGraph,
+      packageGraph,
+      configs,
+      moduleCodeMap
+    } = sdk.getStoreData();
+    let outputFilename = "";
+    if (typeof configs?.[0]?.config?.output?.filename === "string") {
+      outputFilename = configs?.[0]?.config?.output?.filename;
+    }
+    return {
+      root,
+      hash,
+      errors,
+      chunkGraph,
+      moduleGraph,
+      packageGraph,
+      outputFilename,
+      moduleCodeMap
+    };
+  }
+  async bundleDiffManifest() {
+    const { sdk } = this.ctx;
+    const data = sdk.getStoreData();
+    return data;
+  }
+}
+__decorateClass([
+  Router.get(SDK.ServerAPI.API.GetBundleDiffSummary)
+], BundleDiffAPI.prototype, "getBundleDiffSummary", 1);
+__decorateClass([
+  Router.get(SDK.ServerAPI.API.BundleDiffManifest)
+], BundleDiffAPI.prototype, "bundleDiffManifest", 1);
+export {
+  BundleDiffAPI
+};