Duffer Derek

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
0 && (module.exports = {
    Worker: null,
    getNextBuildDebuggerPortOffset: null
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    Worker: function() {
        return Worker;
    },
    getNextBuildDebuggerPortOffset: function() {
        return getNextBuildDebuggerPortOffset;
    }
});
const _jestworker = require("next/dist/compiled/jest-worker");
const _stream = require("stream");
const _utils = require("../server/lib/utils");
const RESTARTED = Symbol('restarted');
const cleanupWorkers = (worker)=>{
    var _worker__workerPool;
    for (const curWorker of ((_worker__workerPool = worker._workerPool) == null ? void 0 : _worker__workerPool._workers) || []){
        var _curWorker__child;
        (_curWorker__child = curWorker._child) == null ? void 0 : _curWorker__child.kill('SIGINT');
    }
};
function getNextBuildDebuggerPortOffset(_) {
    // 0: export worker
    return 0;
}
class Worker {
    constructor(workerPath, options){
        let { enableSourceMaps, timeout, onRestart, logger = console, debuggerPortOffset, isolatedMemory, onActivity, onActivityAbort, ...farmOptions } = options;
        this._onActivity = onActivity;
        this._onActivityAbort = onActivityAbort;
        let restartPromise;
        let resolveRestartPromise;
        let activeTasks = 0;
        this._worker = undefined;
        // ensure we end workers if they weren't before exit
        process.on('exit', ()=>{
            this.close();
        });
        const nodeOptions = (0, _utils.getParsedNodeOptions)();
        const originalOptions = {
            ...nodeOptions
        };
        delete nodeOptions.inspect;
        delete nodeOptions['inspect-brk'];
        delete nodeOptions['inspect_brk'];
        if (debuggerPortOffset !== -1) {
            const nodeDebugType = (0, _utils.getNodeDebugType)(originalOptions);
            if (nodeDebugType) {
                const debuggerAddress = (0, _utils.getParsedDebugAddress)(originalOptions[nodeDebugType]);
                const address = {
                    host: debuggerAddress.host,
                    // current process runs on `address.port`
                    port: debuggerAddress.port === 0 ? 0 : debuggerAddress.port + 1 + debuggerPortOffset
                };
                nodeOptions[nodeDebugType] = (0, _utils.formatDebugAddress)(address);
            }
        }
        if (enableSourceMaps) {
            nodeOptions['enable-source-maps'] = true;
        }
        if (isolatedMemory) {
            delete nodeOptions['max-old-space-size'];
            delete nodeOptions['max_old_space_size'];
        }
        const { nodeOptions: formattedNodeOptions, execArgv } = (0, _utils.formatNodeOptions)(nodeOptions);
        const createWorker = ()=>{
            var _farmOptions_forkOptions, _farmOptions_forkOptions1;
            const workerEnv = {
                ...process.env,
                ...((_farmOptions_forkOptions = farmOptions.forkOptions) == null ? void 0 : _farmOptions_forkOptions.env) || {},
                IS_NEXT_WORKER: 'true',
                NODE_OPTIONS: formattedNodeOptions
            };
            if (workerEnv.FORCE_COLOR === undefined) {
                var _process_stderr;
                // Mirror the enablement heuristic from picocolors (see https://github.com/vercel/next.js/blob/6a40da0345939fe4f7b1ae519b296a86dd103432/packages/next/src/lib/picocolors.ts#L21-L24).
                // Picocolors snapshots `process.env`/`stdout.isTTY` at module load time, so when the worker
                // process bootstraps with piped stdio its own check would disable colors. Re-evaluating the
                // same conditions here lets us opt the worker into color output only when the parent would
                // have seen colors, while still respecting explicit opt-outs like NO_COLOR.
                const supportsColors = !workerEnv.NO_COLOR && !workerEnv.CI && workerEnv.TERM !== 'dumb' && (process.stdout.isTTY || ((_process_stderr = process.stderr) == null ? void 0 : _process_stderr.isTTY));
                if (supportsColors) {
                    workerEnv.FORCE_COLOR = '1';
                }
            }
            this._worker = new _jestworker.Worker(workerPath, {
                ...farmOptions,
                forkOptions: {
                    ...farmOptions.forkOptions,
                    execArgv: [
                        ...execArgv,
                        ...((_farmOptions_forkOptions1 = farmOptions.forkOptions) == null ? void 0 : _farmOptions_forkOptions1.execArgv) || []
                    ],
                    env: workerEnv
                },
                maxRetries: 0
            });
            restartPromise = new Promise((resolve)=>resolveRestartPromise = resolve);
            /**
       * Jest Worker has two worker types, ChildProcessWorker (uses child_process) and NodeThreadWorker (uses worker_threads)
       * Next.js uses ChildProcessWorker by default, but it can be switched to NodeThreadWorker with an experimental flag
       *
       * We only want to handle ChildProcessWorker's orphan process issue, so we access the private property "_child":
       * https://github.com/facebook/jest/blob/b38d7d345a81d97d1dc3b68b8458b1837fbf19be/packages/jest-worker/src/workers/ChildProcessWorker.ts
       *
       * But this property is not available in NodeThreadWorker, so we need to check if we are using ChildProcessWorker
       */ if (!farmOptions.enableWorkerThreads) {
                var _this__worker__workerPool;
                for (const worker of ((_this__worker__workerPool = this._worker._workerPool) == null ? void 0 : _this__worker__workerPool._workers) || []){
                    var _worker__child, // if a child process emits a particular message, we track that as activity
                    // so the parent process can keep track of progress
                    _worker__child1;
                    (_worker__child = worker._child) == null ? void 0 : _worker__child.on('exit', (code, signal)=>{
                        if ((code || signal && signal !== 'SIGINT') && this._worker) {
                            logger.error(`Next.js build worker exited with code: ${code} and signal: ${signal}`);
                            // if a child process doesn't exit gracefully, we want to bubble up the exit code to the parent process
                            process.exit(code ?? 1);
                        }
                    });
                    (_worker__child1 = worker._child) == null ? void 0 : _worker__child1.on('message', ([, data])=>{
                        if (data && typeof data === 'object' && 'type' in data && data.type === 'activity') {
                            onActivityImpl();
                        }
                    });
                }
            }
            let aborted = false;
            const onActivityAbortImpl = ()=>{
                if (!aborted) {
                    this._onActivityAbort == null ? void 0 : this._onActivityAbort.call(this);
                    aborted = true;
                }
            };
            // Listen to the worker's stdout and stderr, if there's any thing logged, abort the activity first
            const abortActivityStreamOnLog = new _stream.Transform({
                transform (_chunk, _encoding, callback) {
                    onActivityAbortImpl();
                    callback();
                }
            });
            // Stop the activity if there's any output from the worker
            this._worker.getStdout().pipe(abortActivityStreamOnLog);
            this._worker.getStderr().pipe(abortActivityStreamOnLog);
            // Pipe the worker's stdout and stderr to the parent process
            this._worker.getStdout().pipe(process.stdout);
            this._worker.getStderr().pipe(process.stderr);
        };
        createWorker();
        const onHanging = ()=>{
            const worker = this._worker;
            if (!worker) return;
            const resolve = resolveRestartPromise;
            createWorker();
            logger.warn(`Sending SIGTERM signal to static worker due to timeout${timeout ? ` of ${timeout / 1000} seconds` : ''}. Subsequent errors may be a result of the worker exiting.`);
            worker.end().then(()=>{
                resolve(RESTARTED);
            });
        };
        let hangingTimer = false;
        const onActivityImpl = ()=>{
            if (hangingTimer) clearTimeout(hangingTimer);
            if (this._onActivity) this._onActivity();
            hangingTimer = activeTasks > 0 && setTimeout(onHanging, timeout);
        };
        // TODO: Remove this once callers stop passing non-serializable values
        // (e.g. functions) in worker method arguments. The structured clone
        // algorithm used by worker_threads rejects functions, unlike
        // child_process which silently drops them via JSON serialization.
        const sanitizeArgs = farmOptions.enableWorkerThreads ? (args)=>JSON.parse(JSON.stringify(args)) : (args)=>args;
        for (const method of farmOptions.exposedMethods){
            if (method.startsWith('_')) continue;
            this[method] = timeout ? async (...args)=>{
                activeTasks++;
                const sanitizedArgs = sanitizeArgs(args);
                try {
                    let attempts = 0;
                    for(;;){
                        onActivityImpl();
                        const result = await Promise.race([
                            this._worker[method](...sanitizedArgs),
                            restartPromise
                        ]);
                        if (result !== RESTARTED) return result;
                        if (onRestart) onRestart(method, sanitizedArgs, ++attempts);
                    }
                } finally{
                    activeTasks--;
                    onActivityImpl();
                }
            } : (...args)=>this._worker[method](...sanitizeArgs(args));
        }
    }
    setOnActivity(onActivity) {
        this._onActivity = onActivity;
    }
    setOnActivityAbort(onActivityAbort) {
        this._onActivityAbort = onActivityAbort;
    }
    end() {
        const worker = this._worker;
        if (!worker) {
            throw Object.defineProperty(new Error('Farm is ended, no more calls can be done to it'), "__NEXT_ERROR_CODE", {
                value: "E265",
                enumerable: false,
                configurable: true
            });
        }
        cleanupWorkers(worker);
        this._worker = undefined;
        return worker.end();
    }
    /**
   * Quietly end the worker if it exists
   */ close() {
        if (this._worker) {
            cleanupWorkers(this._worker);
            this._worker.end();
        }
    }
}

//# sourceMappingURL=worker.js.map