@rspack/cli 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/cli.d.ts

@@ -9,7 +9,14 @@ declare global {
 export declare class RspackCLI {
     colors: RspackCLIColors;
     program: CAC;
+    _actionPromise: Promise<void> | undefined;
     constructor();
+    /**
+     * Wraps an async action handler so its promise is captured and can be
+     * awaited in `run()`. CAC's `parse()` does not await async actions,
+     * so without this wrapper, rejections become unhandled.
+     */
+    wrapAction<T extends (...args: any[]) => Promise<void>>(fn: T): T;
     buildCompilerConfig(options: CommonOptionsForBuildAndServe, rspackCommand: Command): Promise<RspackOptions | MultiRspackOptions>;
     createCompiler(config: RspackOptions | MultiRspackOptions, callback?: (e: Error | null, res?: Stats | MultiStats) => void): Promise<MultiCompiler | Compiler | null>;
     private createColors;

package/dist/exit-hook.js

@@ -0,0 +1,61 @@
+import node_process from "node:process";
+const asyncCallbacks = new Set();
+const callbacks = new Set();
+let isCalled = false;
+let isRegistered = false;
+async function exit(shouldManuallyExit, isSynchronous, signal) {
+    if (isCalled) return;
+    isCalled = true;
+    if (asyncCallbacks.size > 0 && isSynchronous) console.error("SYNCHRONOUS TERMINATION NOTICE: When explicitly exiting the process via process.exit or via a parent process, asynchronous tasks in your exitHooks will not run. Either remove these tasks, use gracefulExit() instead of process.exit(), or ensure your parent process sends a SIGINT to the process running this code.");
+    const exitCode = 128 + signal;
+    const done = (force = false)=>{
+        if (true === force || true === shouldManuallyExit) node_process.exit(exitCode);
+    };
+    for (const callback of callbacks)callback(exitCode);
+    if (isSynchronous) return void done();
+    const promises = [];
+    let forceAfter = 0;
+    for (const [callback, wait] of asyncCallbacks){
+        forceAfter = Math.max(forceAfter, wait);
+        promises.push(Promise.resolve(callback(exitCode)));
+    }
+    const asyncTimer = setTimeout(()=>{
+        done(true);
+    }, forceAfter);
+    await Promise.all(promises);
+    clearTimeout(asyncTimer);
+    done();
+}
+function addHook(options) {
+    const { onExit, wait, isSynchronous } = options;
+    const asyncCallbackConfig = [
+        onExit,
+        wait
+    ];
+    if (isSynchronous) callbacks.add(onExit);
+    else asyncCallbacks.add(asyncCallbackConfig);
+    if (!isRegistered) {
+        isRegistered = true;
+        node_process.once('beforeExit', exit.bind(void 0, true, false, -128));
+        node_process.once('SIGINT', exit.bind(void 0, true, false, 2));
+        node_process.once('SIGTERM', exit.bind(void 0, true, false, 15));
+        node_process.once('exit', exit.bind(void 0, false, true, 0));
+        node_process.on('message', (message)=>{
+            if ('shutdown' === message) exit(true, true, -128);
+        });
+    }
+    return ()=>{
+        if (isSynchronous) callbacks.delete(onExit);
+        else asyncCallbacks.delete(asyncCallbackConfig);
+    };
+}
+function asyncExitHook(onExit, options = {}) {
+    if ('function' != typeof onExit) throw new TypeError('onExit must be a function');
+    if (!('number' == typeof options.wait && options.wait > 0)) throw new TypeError('wait must be set to a positive numeric value');
+    return addHook({
+        onExit,
+        wait: options.wait,
+        isSynchronous: false
+    });
+}
+export { asyncExitHook };