@rsdoctor/sdk 0.4.8 → 0.4.10

package/dist/cjs/sdk/multiple/controller.js

@@ -55,7 +55,7 @@ class RsdoctorSDKController {
     stage,
     extraConfig
   }) {
-    const slave = new import_slave.RsdoctorSlaveSDK({
+    const slave = new import_slave.RsdoctorPrimarySDK({
       name,
       stage,
       controller: this,

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

@@ -28,14 +28,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var slave_exports = {};
 __export(slave_exports, {
-  RsdoctorSlaveSDK: () => RsdoctorSlaveSDK
+  RsdoctorPrimarySDK: () => RsdoctorPrimarySDK
 });
 module.exports = __toCommonJS(slave_exports);
 var import_path = __toESM(require("path"));
 var import_sdk = require("../sdk");
 var import_server = require("./server");
 let id = 1;
-class RsdoctorSlaveSDK extends import_sdk.RsdoctorWebpackSDK {
+class RsdoctorPrimarySDK extends import_sdk.RsdoctorSDK {
   constructor({
     name,
     stage,
@@ -99,5 +99,5 @@ class RsdoctorSlaveSDK extends import_sdk.RsdoctorWebpackSDK {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RsdoctorSlaveSDK
+  RsdoctorPrimarySDK
 });

package/dist/cjs/sdk/sdk/core.js

@@ -40,6 +40,7 @@ var import_process = __toESM(require("process"));
 var import_tapable = require("tapable");
 var import_logger = require("@rsdoctor/utils/logger");
 var import_utils = require("../utils");
+const jc = require("json-cycle");
 class SDKCore {
   constructor({ name, root }) {
     this.hooks = {
@@ -130,6 +131,9 @@ class SDKCore {
       }
       const jsonStr = await (async () => {
         try {
+          if (key === "configs") {
+            return JSON.stringify(jc.decycle(data));
+          }
           return JSON.stringify(data);
         } catch (error) {
           return import_build.Json.stringify(data);

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

@@ -1,7 +1,9 @@
 "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)
@@ -16,16 +18,489 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 sdk_exports = {};
 __export(sdk_exports, {
-  RsdoctorSDK: () => import_webpack.RsdoctorWebpackSDK
+  RsdoctorSDK: () => RsdoctorSDK
 });
 module.exports = __toCommonJS(sdk_exports);
-__reExport(sdk_exports, require("./webpack"), module.exports);
-var import_webpack = require("./webpack");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_error = require("@rsdoctor/utils/error");
+var import_types = require("@rsdoctor/types");
+var import_build = require("@rsdoctor/utils/build");
+var import_source_map = require("source-map");
+var import_graph = require("@rsdoctor/graph");
+var import_logger = require("@rsdoctor/utils/logger");
+var import_server = require("../server");
+var import_fakeServer = require("../server/fakeServer");
+var import_core = require("./core");
+var import_common = require("@rsdoctor/utils/common");
+var import_lodash = require("lodash");
+__reExport(sdk_exports, require("../utils/openBrowser"), module.exports);
+const jc = require("json-cycle");
+class RsdoctorSDK extends import_core.SDKCore {
+  constructor(options) {
+    super(options);
+    this._summary = { costs: [] };
+    this._configs = [];
+    this._errors = [];
+    this._loader = [];
+    this._loaderStart = [];
+    this._resolver = [];
+    this._plugin = {};
+    this._moduleGraph = new import_graph.ModuleGraph();
+    this._chunkGraph = new import_graph.ChunkGraph();
+    this._rawSourceMapCache = /* @__PURE__ */ new Map();
+    this._sourceMap = /* @__PURE__ */ new Map();
+    this.server = options.config?.noServer ? new import_fakeServer.RsdoctorFakeServer(this, void 0) : new import_server.RsdoctorServer(this, options.port, {
+      innerClientPath: options.config?.innerClientPath || "",
+      printServerUrl: options.config?.printLog?.serverUrls
+    });
+    this.type = (0, import_lodash.isNumber)(options.type) ? options.type : import_types.SDK.ToDataType.Normal;
+    this.extraConfig = options.config;
+  }
+  async bootstrap() {
+    (0, import_logger.debug)(() => `${Date.now()}`, "[RsdoctorSDK][bootstrap start]");
+    this.server && await this.server.bootstrap();
+    await super.bootstrap();
+    (0, import_logger.debug)(
+      () => `${Date.now()} ${this.server.origin}`,
+      "[RsdoctorSDK][bootstrap end]"
+    );
+  }
+  async dispose() {
+    (0, import_logger.debug)(() => `${Date.now()}`, "[RsdoctorSDK][dispose start]");
+    this.server && await this.server.dispose();
+    await super.dispose();
+    (0, import_logger.debug)(() => `${Date.now()}`, "[RsdoctorSDK][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 import_build.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 import_build.File.fse.writeFile(filePath, content);
+  }
+  clear() {
+    this._errors = [];
+    this._loader = [];
+    this._resolver = [];
+    this._plugin = {};
+    this._moduleGraph = new import_graph.ModuleGraph();
+    this._chunkGraph = new import_graph.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 import_source_map.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(
+        import_error.DevToolError.from(item, {
+          code: this.name
+        })
+      );
+    });
+    this.onDataReport();
+  }
+  reportLoader(data) {
+    data.forEach((item) => {
+      if (this.extraConfig?.mode === import_types.SDK.IMode[import_types.SDK.IMode.brief]) {
+        item.loaders.forEach((_loader) => {
+          _loader.input = "";
+          _loader.result = "";
+        });
+      }
+      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();
+  }
+  reportLoaderStartOrEnd(data) {
+    const _builtinLoader = data.loaders[0];
+    if (_builtinLoader.startAt) {
+      this._loaderStart.push(data);
+    } else if (_builtinLoader.endAt) {
+      const matchLoaderStart = this._loaderStart.find(
+        (e) => e.resource.path === data.resource.path && e.loaders[0].loader === _builtinLoader.loader
+      );
+      if (matchLoaderStart) {
+        matchLoaderStart.loaders[0].result = _builtinLoader.result;
+        matchLoaderStart.loaders[0].endAt = _builtinLoader.endAt;
+        this.reportLoader([matchLoaderStart]);
+      }
+    }
+  }
+  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) {
+    (0, import_logger.debug)(() => `data size: ${data.size()}`, "[SDK.reportModuleGraph][start]");
+    this._moduleGraph.fromInstance(data);
+    this.createPackageGraph();
+    this.onDataReport();
+    (0, import_logger.debug)(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK reportModuleGraph][end]"
+    );
+  }
+  reportPackageGraph(data) {
+    (0, import_logger.debug)(() => "[SDK.reportPackageGraph][start]");
+    if (!this._packageGraph) {
+      this._packageGraph = data;
+    }
+    this.onDataReport();
+    (0, import_logger.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() {
+    (0, import_logger.debug)(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK.createPackageGraph][start]"
+    );
+    if (!this._packageGraph) {
+      const pkgGraph = import_graph.PackageGraph.fromModuleGraph(
+        this._moduleGraph,
+        this.root,
+        (path2) => {
+          try {
+            const exists = import_build.File.fse.existsSync(path2);
+            if (exists) {
+              (0, import_logger.debug)(
+                () => `sdk.PackageGraph package.json exists: ${exists}, path: ${path2}`,
+                "[SDK.createPackageGraph][load]"
+              );
+              return import_build.File.fse.readJSONSync(path2);
+            }
+          } catch (error) {
+            const { message, stack } = error;
+            (0, import_logger.debug)(
+              () => `sdk.createPackageGraph error, path: ${path2}, error message: ${stack || message}`,
+              "[SDK.createPackageGraph][error]"
+            );
+          }
+        }
+      );
+      this._packageGraph = pkgGraph;
+      (0, import_logger.debug)(
+        () => `sdk._packageGraph packages: ${this._packageGraph.getPackages().length}`,
+        "[SDK.createPackageGraph][end]"
+      );
+    }
+  }
+  async writeStore(options) {
+    (0, import_logger.debug)(() => `sdk.writeStore has run.`, "[SDK.writeStore][end]");
+    if (this.extraConfig?.mode === import_types.SDK.IMode[import_types.SDK.IMode.brief]) {
+      const clientHtmlPath = this.extraConfig.innerClientPath ? this.extraConfig.innerClientPath : require.resolve("@rsdoctor/client");
+      if (this.extraConfig.brief?.writeDataJson) {
+        await this.saveManifest(this.getStoreData(), options || {});
+      }
+      return this.inlineScriptsAndStyles(clientHtmlPath);
+    }
+    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}${import_types.SDK.ServerAPI.API.LoadDataByKey}/${e}`
+          ];
+        } else {
+          t[e] = dataValue[_e];
+        }
+        return t;
+      }, {}),
+      __LOCAL__SERVER__: true,
+      __SOCKET__PORT__: this.server.socketUrl.port.toString(),
+      __SOCKET__URL__: this.server.socketUrl.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();
+  }
+  addRsdoctorDataToHTML(storeData, htmlContent) {
+    let compressTextScripts = `<script>window.${import_types.Constants.WINDOW_RSDOCTOR_TAG}={}</script>`;
+    for (let key of Object.keys(storeData)) {
+      const data = storeData[key];
+      const jsonStrFn = () => {
+        try {
+          if (key === "configs") {
+            return JSON.stringify(jc.decycle(data));
+          }
+          return JSON.stringify(data);
+        } catch (error) {
+          console.error(error);
+          return "";
+        }
+      };
+      const compressText = import_common.Algorithm.compressText(jsonStrFn());
+      compressTextScripts = `${compressTextScripts} <script>window.${import_types.Constants.WINDOW_RSDOCTOR_TAG}.${key}=${JSON.stringify(compressText)}</script>`;
+    }
+    compressTextScripts = `${compressTextScripts} <script>window.${import_types.Constants.WINDOW_RSDOCTOR_TAG}.enableRoutes=${JSON.stringify(this.getClientRoutes())}</script>`;
+    htmlContent = htmlContent.replace("<body>", `<body>${compressTextScripts}`);
+    return htmlContent;
+  }
+  inlineScriptsAndStyles(htmlFilePath) {
+    function inlineScripts(basePath2, scripts) {
+      return scripts.map((src) => {
+        const scriptPath = import_path.default.resolve(basePath2, src);
+        try {
+          const scriptContent = import_fs_extra.default.readFileSync(scriptPath, "utf-8");
+          return `<script>${scriptContent}</script>`;
+        } catch (error) {
+          console.error(`Could not read script at ${scriptPath}:`, error);
+          return "";
+        }
+      }).join("");
+    }
+    function inlineCss(basePath2, cssFiles) {
+      return cssFiles.map((href) => {
+        const cssPath = import_path.default.resolve(basePath2, href);
+        try {
+          const cssContent = import_fs_extra.default.readFileSync(cssPath, "utf-8");
+          return `<style>${cssContent}</style>`;
+        } catch (error) {
+          console.error(`Could not read CSS at ${cssPath}:`, error);
+          return "";
+        }
+      }).join("");
+    }
+    let htmlContent = import_fs_extra.default.readFileSync(htmlFilePath, "utf-8");
+    const basePath = import_path.default.dirname(htmlFilePath);
+    const scriptSrcs = Array.from(
+      htmlContent.matchAll(
+        /<script\s+(?:defer="defer"|defer)\s+src=["'](.+?)["']><\/script>/g
+      ),
+      (m) => m[1]
+    );
+    const cssHrefs = Array.from(
+      htmlContent.matchAll(/<link\s+href=["'](.+?)["']\s+rel="stylesheet">/g),
+      (m) => m[1]
+    );
+    htmlContent = htmlContent.replace(
+      /<script\s+.*?src=["'].*?["']><\/script>/g,
+      ""
+    );
+    htmlContent = htmlContent.replace(
+      /<link\s+.*?rel=["']stylesheet["'].*?>/g,
+      ""
+    );
+    const inlinedScripts = inlineScripts(basePath, scriptSrcs);
+    const inlinedCss = inlineCss(basePath, cssHrefs);
+    const index = htmlContent.indexOf("</body>");
+    htmlContent = htmlContent.slice(0, index) + inlinedCss + inlinedScripts + htmlContent.slice(index);
+    htmlContent = this.addRsdoctorDataToHTML(this.getStoreData(), htmlContent);
+    const outputFilePath = import_path.default.resolve(
+      this.outputDir,
+      this.extraConfig?.brief?.reportHtmlName || "rsdoctor-report.html"
+    );
+    import_fs_extra.default.outputFileSync(outputFilePath, htmlContent, {
+      encoding: "utf-8",
+      flag: "w"
+    });
+    return outputFilePath;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RsdoctorSDK,
-  ...require("./webpack")
+  ...require("../utils/openBrowser")
 });

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

@@ -1,4 +1,4 @@
-import { RsdoctorSlaveSDK } from "./slave";
+import { RsdoctorPrimarySDK } from "./slave";
 class RsdoctorSDKController {
   constructor(root = process.cwd()) {
     this.slaves = [];
@@ -32,7 +32,7 @@ class RsdoctorSDKController {
     stage,
     extraConfig
   }) {
-    const slave = new RsdoctorSlaveSDK({
+    const slave = new RsdoctorPrimarySDK({
       name,
       stage,
       controller: this,

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

@@ -1,8 +1,8 @@
 import path from "path";
-import { RsdoctorWebpackSDK } from "../sdk";
+import { RsdoctorSDK } from "../sdk";
 import { RsdoctorSlaveServer } from "./server";
 let id = 1;
-class RsdoctorSlaveSDK extends RsdoctorWebpackSDK {
+class RsdoctorPrimarySDK extends RsdoctorSDK {
   constructor({
     name,
     stage,
@@ -65,5 +65,5 @@ class RsdoctorSlaveSDK extends RsdoctorWebpackSDK {
   }
 }
 export {
-  RsdoctorSlaveSDK
+  RsdoctorPrimarySDK
 };

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

@@ -5,6 +5,7 @@ import path from "path";
 import { createHash } from "crypto";
 import process from "process";
 import { AsyncSeriesHook } from "tapable";
+const jc = require("json-cycle");
 import { debug } from "@rsdoctor/utils/logger";
 import { transformDataUrls } from "../utils";
 class SDKCore {
@@ -97,6 +98,9 @@ class SDKCore {
       }
       const jsonStr = await (async () => {
         try {
+          if (key === "configs") {
+            return JSON.stringify(jc.decycle(data));
+          }
           return JSON.stringify(data);
         } catch (error) {
           return Json.stringify(data);