@rspack/cli 0.2.11 → 0.2.12-canary-8aa969c-20230816005959

package/dist/rspack-cli.js

@@ -15,7 +15,9 @@ const core_1 = require("@rspack/core");
 const options_1 = require("./utils/options");
 const loadConfig_1 = require("./utils/loadConfig");
 const findConfig_1 = __importDefault(require("./utils/findConfig"));
+const core_2 = require("@rspack/core");
 const path_1 = __importDefault(require("path"));
+const profile_1 = require("./utils/profile");
 const defaultEntry = "src/index";
 class RspackCLI {
     constructor() {
@@ -115,6 +117,22 @@ class RspackCLI {
                     }
                 });
             }
+            if (process.env.RSPACK_PROFILE) {
+                const { default: exitHook } = await import("exit-hook");
+                Object.entries((0, profile_1.resolveProfile)(process.env.RSPACK_PROFILE)).forEach(([kind, value]) => {
+                    var _a, _b;
+                    if (kind === "TRACE" && "filter" in value) {
+                        (0, core_2.experimental_registerGlobalTrace)(value.filter, value.layer, value.output);
+                        exitHook(core_2.experimental_cleanupGlobalTrace);
+                    }
+                    else if (kind === "JSCPU") {
+                        ((_a = item.plugins) !== null && _a !== void 0 ? _a : (item.plugins = [])).push(new profile_1.RspackProfileJSCPUProfilePlugin(value.output));
+                    }
+                    else if (kind === "LOGGING") {
+                        ((_b = item.plugins) !== null && _b !== void 0 ? _b : (item.plugins = [])).push(new profile_1.RspackProfileLoggingPlugin(value.output));
+                    }
+                });
+            }
             // cli --watch overrides the watch config
             if (options.watch) {
                 item.watch = options.watch;

package/dist/utils/profile.d.ts

@@ -0,0 +1,35 @@
+import { experimental_registerGlobalTrace as registerGlobalTrace } from "@rspack/core";
+type JSCPUProfileOptionsOutput = string;
+export type JSCPUProfileOptions = {
+    output: JSCPUProfileOptionsOutput;
+};
+type ParametersOfRegisterGlobalTrace = Parameters<typeof registerGlobalTrace>;
+type RustTraceOptionsFilter = ParametersOfRegisterGlobalTrace[0];
+type RustTraceOptionsLayer = ParametersOfRegisterGlobalTrace[1];
+type RustTraceOptionsOutput = ParametersOfRegisterGlobalTrace[2];
+export type RustTraceOptions = {
+    filter: RustTraceOptionsFilter;
+    layer: RustTraceOptionsLayer;
+    output: RustTraceOptionsOutput;
+};
+type LoggingOutputOptions = string;
+export type LoggingOptions = {
+    output: LoggingOutputOptions;
+};
+export type ProfileOptions = {
+    TRACE?: RustTraceOptions;
+    JSCPU?: JSCPUProfileOptions;
+    LOGGING?: LoggingOptions;
+};
+export declare function resolveProfile(value: string): ProfileOptions;
+export declare class RspackProfileJSCPUProfilePlugin {
+    private output;
+    constructor(output: string);
+    apply(compiler: any): void;
+}
+export declare class RspackProfileLoggingPlugin {
+    private output;
+    constructor(output: string);
+    apply(compiler: any): void;
+}
+export {};

package/dist/utils/profile.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RspackProfileLoggingPlugin = exports.RspackProfileJSCPUProfilePlugin = exports.resolveProfile = void 0;
+const inspector_1 = __importDefault(require("inspector"));
+const fs_1 = __importDefault(require("fs"));
+const url_1 = require("url");
+const defaultJSCPUProfileOutput = `./rspack.jscpuprofile`;
+const defaultRustTraceChromeOutput = `./rspack.trace`;
+const defaultRustTraceLoggerOutput = `stdout`;
+const defaultRustTraceFilter = "trace";
+const defaultRustTraceLayer = "chrome";
+const defaultLoggingOutput = `./rspack.logging`;
+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;
+    }, {});
+}
+exports.resolveProfile = resolveProfile;
+// 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();
+        });
+    }
+}
+exports.RspackProfileJSCPUProfilePlugin = RspackProfileJSCPUProfilePlugin;
+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();
+        });
+    }
+}
+exports.RspackProfileLoggingPlugin = RspackProfileLoggingPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/cli",
-  "version": "0.2.11",
+  "version": "0.2.12-canary-8aa969c-20230816005959",
   "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.11",
-    "@rspack/dev-server": "0.2.11"
+    "@rspack/core": "0.2.12-canary-8aa969c-20230816005959",
+    "@rspack/dev-server": "0.2.12-canary-8aa969c-20230816005959"
   },
   "scripts": {
     "build": "rimraf dist/ && tsc -b ./tsconfig.build.json --force",