@rspack/cli 0.2.12 → 0.3.0

package/dist/rspack-cli.js

@@ -115,6 +115,10 @@ class RspackCLI {
                     }
                 });
             }
+            if (process.env.RSPACK_PROFILE) {
+                const { applyProfile } = await import("./utils/profile.js");
+                await applyProfile(process.env.RSPACK_PROFILE, item);
+            }
             // cli --watch overrides the watch config
             if (options.watch) {
                 item.watch = options.watch;

package/dist/utils/profile.d.ts

@@ -0,0 +1,2 @@
+import { RspackOptions } from "@rspack/core";
+export declare function applyProfile(profileValue: string, item: RspackOptions): Promise<void>;

package/dist/utils/profile.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyProfile = void 0;
+const inspector_1 = __importDefault(require("inspector"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const core_1 = require("@rspack/core");
+const timestamp = Date.now();
+const defaultOutputDirname = path_1.default.resolve(`.rspack-profile-${timestamp}`);
+const defaultJSCPUProfileOutput = path_1.default.join(defaultOutputDirname, `./jscpuprofile.json`);
+const defaultRustTraceChromeOutput = path_1.default.join(defaultOutputDirname, `./trace.json`);
+const defaultRustTraceLoggerOutput = `stdout`;
+const defaultRustTraceFilter = "trace";
+const defaultRustTraceLayer = "chrome";
+const defaultLoggingOutput = path_1.default.join(defaultOutputDirname, `./logging.json`);
+function resolveProfile(value) {
+    if (value.toUpperCase() === "ALL") {
+        return {
+            TRACE: {
+                filter: defaultRustTraceFilter,
+                layer: defaultRustTraceLayer,
+                output: defaultRustTraceChromeOutput
+            },
+            JSCPU: { output: defaultJSCPUProfileOutput },
+            LOGGING: { output: defaultLoggingOutput }
+        };
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+        return {
+            TRACE: resolveRustTraceOptions(value.slice(1, value.length - 1)),
+            JSCPU: { output: defaultJSCPUProfileOutput },
+            LOGGING: { output: defaultLoggingOutput }
+        };
+    }
+    return value.split("|").reduce((acc, cur) => {
+        if (cur.toUpperCase().startsWith("TRACE")) {
+            acc.TRACE = resolveRustTraceOptions(cur.slice(6));
+        }
+        if (cur.toUpperCase().startsWith("JSCPU")) {
+            acc.JSCPU = resolveJSCPUProfileOptions(cur.slice(6));
+        }
+        if (cur.toUpperCase().startsWith("LOGGING")) {
+            acc.LOGGING = resolveLoggingOptions(cur.slice(8));
+        }
+        return acc;
+    }, {});
+}
+// JSCPU=value
+function resolveJSCPUProfileOptions(value) {
+    // output=filepath
+    if (value.includes("=")) {
+        const parsed = new url_1.URLSearchParams(value);
+        return { output: parsed.get("output") || defaultJSCPUProfileOutput };
+    }
+    // filepath
+    return { output: value || defaultJSCPUProfileOutput };
+}
+// TRACE=value
+function resolveRustTraceOptions(value) {
+    // filter=trace&output=stdout&layer=logger
+    if (value.includes("=")) {
+        const parsed = new url_1.URLSearchParams(value);
+        const filter = parsed.get("filter") || defaultRustTraceFilter;
+        const layer = parsed.get("layer") || defaultRustTraceLayer;
+        const output = layer === "chrome"
+            ? parsed.get("output") || defaultRustTraceChromeOutput
+            : parsed.get("output") || defaultRustTraceLoggerOutput;
+        if (layer !== "chrome" && layer !== "logger") {
+            throw new Error(`${layer} is not a valid layer, should be chrome or logger`);
+        }
+        return {
+            filter,
+            layer,
+            output
+        };
+    }
+    // trace
+    return {
+        filter: value || defaultRustTraceFilter,
+        layer: defaultRustTraceLayer,
+        output: defaultRustTraceChromeOutput
+    };
+}
+// LOGGING=value
+function resolveLoggingOptions(value) {
+    // output=filepath
+    if (value.includes("=")) {
+        const parsed = new url_1.URLSearchParams(value);
+        return { output: parsed.get("output") || defaultLoggingOutput };
+    }
+    // filepath
+    return { output: value || defaultLoggingOutput };
+}
+class RspackProfileJSCPUProfilePlugin {
+    constructor(output) {
+        this.output = output;
+    }
+    apply(compiler) {
+        const session = new inspector_1.default.Session();
+        session.connect();
+        session.post("Profiler.enable");
+        session.post("Profiler.start");
+        compiler.hooks.done.tapAsync(RspackProfileJSCPUProfilePlugin.name, (stats, callback) => {
+            if (compiler.watchMode)
+                return callback();
+            session.post("Profiler.stop", (error, param) => {
+                if (error) {
+                    console.error("Failed to generate JS CPU profile:", error);
+                    return;
+                }
+                fs_1.default.writeFileSync(this.output, JSON.stringify(param.profile));
+            });
+            return callback();
+        });
+    }
+}
+class RspackProfileLoggingPlugin {
+    constructor(output) {
+        this.output = output;
+    }
+    apply(compiler) {
+        compiler.hooks.done.tapAsync(RspackProfileLoggingPlugin.name, (stats, callback) => {
+            if (compiler.watchMode)
+                return callback();
+            const logging = stats.toJson({
+                all: false,
+                logging: "verbose",
+                loggingTrace: true
+            });
+            fs_1.default.writeFileSync(this.output, JSON.stringify(logging));
+            return callback();
+        });
+    }
+}
+async function applyProfile(profileValue, item) {
+    const { default: exitHook } = await import("exit-hook");
+    const entries = Object.entries(resolveProfile(profileValue));
+    if (entries.length <= 0)
+        return;
+    await fs_1.default.promises.mkdir(defaultOutputDirname);
+    entries.forEach(([kind, value]) => {
+        var _a, _b;
+        if (kind === "TRACE" && "filter" in value) {
+            (0, core_1.experimental_registerGlobalTrace)(value.filter, value.layer, value.output);
+            exitHook(core_1.experimental_cleanupGlobalTrace);
+        }
+        else if (kind === "JSCPU") {
+            ((_a = item.plugins) !== null && _a !== void 0 ? _a : (item.plugins = [])).push(new RspackProfileJSCPUProfilePlugin(value.output));
+        }
+        else if (kind === "LOGGING") {
+            ((_b = item.plugins) !== null && _b !== void 0 ? _b : (item.plugins = [])).push(new RspackProfileLoggingPlugin(value.output));
+        }
+    });
+}
+exports.applyProfile = applyProfile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/cli",
-  "version": "0.2.12",
+  "version": "0.3.0",
   "license": "MIT",
   "description": "CLI for rspack",
   "bin": {
@@ -31,13 +31,14 @@
   "dependencies": {
     "@discoveryjs/json-ext": "^0.5.7",
     "colorette": "2.0.19",
+    "exit-hook": "^3.2.0",
     "interpret": "^3.1.1",
     "rechoir": "^0.8.0",
     "semver": "6.3.0",
     "webpack-bundle-analyzer": "4.6.1",
     "yargs": "17.6.2",
-    "@rspack/core": "0.2.12",
-    "@rspack/dev-server": "0.2.12"
+    "@rspack/core": "0.3.0",
+    "@rspack/dev-server": "0.3.0"
   },
   "scripts": {
     "build": "rimraf dist/ && tsc -b ./tsconfig.build.json --force",