@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/tasks-runner/running-tasks/batch-process.d.ts

@@ -1,74 +0,0 @@
-import type { ChildProcess, Serializable } from 'child_process';
-import type { TaskResult } from '../../config/misc-interfaces';
-import { BatchResults } from '../batch/batch-messages';
-export declare class BatchProcess {
-    private childProcess;
-    private executorName;
-    private exitCallbacks;
-    private batchResultsCallbacks;
-    private taskResultsCallbacks;
-    private outputCallbacks;
-    /**
-     * File holding all stdout/stderr held back from the live stream under log
-     * grouping. It is rendered as a fold by a full-output run and by any batch
-     * that reported a failed or stopped task (alongside per-task rendering), and
-     * by any batch that crashed or was stopped before reporting (with redirect
-     * lines — no per-task blocks exist there), so that a diagnostic no task
-     * claimed — a crash, a config-phase error, a runner's summary — is not lost.
-     * Only a batch whose every task succeeded on the default style discards it
-     * unread. Crashiness is unknowable while capturing, so it is always written.
-     *
-     * It goes to disk rather than a string because a batch is long-lived (Gradle
-     * runs one for the whole command) and its output has no bound. Accumulating
-     * that in memory grows without limit and eventually exceeds the maximum
-     * length of a JS string.
-     */
-    private capturedOutputPath;
-    private capturedOutputFd;
-    /**
-     * Set once the capture is released. A chunk can still arrive after that —
-     * stdout delivers past the exit event — and reopening then would mint a
-     * second numbered file that nothing ever cleans up.
-     */
-    private capturedOutputDiscarded;
-    /**
-     * Set when writing the capture failed. Distinct from discarded: the bytes
-     * already on disk are still the best record of the batch, so the file is kept
-     * and rendered, while everything after the failure goes live to the terminal.
-     */
-    private capturedOutputFailed;
-    private static capturedOutputCount;
-    constructor(childProcess: ChildProcess, executorName: string);
-    onExit(cb: (code: number) => void): void;
-    onBatchResults(cb: (results: BatchResults) => void): void;
-    onTaskResults(cb: (task: string, result: TaskResult) => void): void;
-    onOutput(cb: (output: string) => void): void;
-    private capture;
-    /**
-     * Path to the file holding everything held back from the live stream under
-     * log grouping, or undefined if nothing was captured. Used to render the whole
-     * batch as one fold, so output no task claimed is not lost.
-     *
-     * The file is deliberately left open rather than closed here. A worker's
-     * stdout can deliver after its exit event — which is what `getResults()`
-     * settles on — and leaving the fd open keeps such a chunk appending to this
-     * same file instead of minting a second numbered one that nothing cleans up.
-     * The caller reads the file once, synchronously, while rendering the fold, so
-     * anything arriving after that read is not shown; writes are unbuffered, so
-     * the read always sees a complete prefix of what has arrived by then.
-     */
-    getCapturedOutputPath(): string | undefined;
-    /** Releases the capture file. Safe to call more than once. */
-    discardCapturedOutput(): void;
-    /**
-     * Closes the fd and unlinks the file, leaving no path behind for a caller to
-     * read. Tolerates a partially-initialized capture, since it also runs when
-     * opening or writing the file is what failed.
-     */
-    private releaseCapturedOutput;
-    /** Closes the fd, keeping the file and its path readable. */
-    private closeCapturedOutput;
-    getResults(): Promise<BatchResults>;
-    send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals): Promise<void>;
-}

package/dist/src/tasks-runner/running-tasks/batch-process.js

@@ -1,263 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchProcess = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const native_1 = require("../../native");
-const cache_directory_1 = require("../../utils/cache-directory");
-const exit_codes_1 = require("../../utils/exit-codes");
-const output_1 = require("../../utils/output");
-const batch_messages_1 = require("../batch/batch-messages");
-class BatchProcess {
-    constructor(childProcess, executorName) {
-        this.childProcess = childProcess;
-        this.executorName = executorName;
-        this.exitCallbacks = [];
-        this.batchResultsCallbacks = [];
-        this.taskResultsCallbacks = [];
-        this.outputCallbacks = [];
-        /**
-         * Set once the capture is released. A chunk can still arrive after that —
-         * stdout delivers past the exit event — and reopening then would mint a
-         * second numbered file that nothing ever cleans up.
-         */
-        this.capturedOutputDiscarded = false;
-        /**
-         * Set when writing the capture failed. Distinct from discarded: the bytes
-         * already on disk are still the best record of the batch, so the file is kept
-         * and rendered, while everything after the failure goes live to the terminal.
-         */
-        this.capturedOutputFailed = false;
-        this.childProcess.on('message', (message) => {
-            switch (message.type) {
-                case batch_messages_1.BatchMessageType.CompleteTask: {
-                    for (const cb of this.taskResultsCallbacks) {
-                        cb(message.task, message.result);
-                    }
-                    break;
-                }
-                case batch_messages_1.BatchMessageType.CompleteBatchExecution: {
-                    for (const cb of this.batchResultsCallbacks) {
-                        cb(message.results);
-                    }
-                    break;
-                }
-                case batch_messages_1.BatchMessageType.RunTasks: {
-                    break;
-                }
-                default: {
-                    // Re-emit any non-batch messages from the task process
-                    if (process.send) {
-                        process.send(message);
-                    }
-                }
-            }
-        });
-        this.childProcess.once('exit', (code, signal) => {
-            if (code === null)
-                code = (0, exit_codes_1.signalToCode)(signal);
-            for (const cb of this.exitCallbacks) {
-                cb(code);
-            }
-        });
-        // Capture stdout output
-        if (this.childProcess.stdout) {
-            this.childProcess.stdout.on('data', (chunk) => {
-                const text = chunk.toString();
-                // When batch output is being folded, the live copy is suppressed to
-                // keep each group contiguous; it is retained (see capturedOutputPath)
-                // for the renderings that need it. Otherwise, maintain
-                // current terminal output behavior. These chunks are forwarded raw and
-                // routinely end mid-line, so they go through `output` to keep its line
-                // tracking accurate for whatever prints next.
-                if ((0, output_1.shouldGroupBatchOutput)()) {
-                    this.capture(chunk);
-                }
-                else {
-                    output_1.output.writeTaskOutputChunk(chunk);
-                }
-                // Notify callbacks for TUI
-                for (const cb of this.outputCallbacks) {
-                    cb(text);
-                }
-            });
-        }
-        // Capture stderr output
-        if (this.childProcess.stderr) {
-            this.childProcess.stderr.on('data', (chunk) => {
-                const text = chunk.toString();
-                if ((0, output_1.shouldGroupBatchOutput)()) {
-                    this.capture(chunk, process.stderr);
-                }
-                else {
-                    // Maintain current terminal output behavior
-                    output_1.output.writeTaskOutputChunk(chunk, process.stderr);
-                }
-                // Notify callbacks for TUI
-                for (const cb of this.outputCallbacks) {
-                    cb(text);
-                }
-            });
-        }
-    }
-    onExit(cb) {
-        this.exitCallbacks.push(cb);
-    }
-    onBatchResults(cb) {
-        this.batchResultsCallbacks.push(cb);
-    }
-    onTaskResults(cb) {
-        this.taskResultsCallbacks.push(cb);
-    }
-    onOutput(cb) {
-        this.outputCallbacks.push(cb);
-    }
-    capture(chunk, stream = process.stdout) {
-        // Only a released capture stops recording; a handed-over one keeps
-        // appending until the fold is rendered.
-        if (this.capturedOutputDiscarded) {
-            return;
-        }
-        if (this.capturedOutputFailed) {
-            // Capture is over, but the output is not optional. Everything from here
-            // goes straight to the terminal, on the stream it arrived on.
-            output_1.output.writeTaskOutputChunk(chunk, stream);
-            return;
-        }
-        // Hoisted so the catch can tell how much of this chunk reached the file: a
-        // `writeSync` that fails partway leaves a prefix on disk, and replaying the
-        // whole chunk live would print that prefix twice - once now, once when the
-        // fold reads the file.
-        const bytes = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
-        let written = 0;
-        try {
-            if (this.capturedOutputFd === undefined) {
-                const dir = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'batch-outputs');
-                (0, fs_1.mkdirSync)(dir, { recursive: true });
-                const name = `${this.executorName.replace(/[^a-zA-Z0-9]+/g, '-')}-${process.pid}-${++BatchProcess.capturedOutputCount}.log`;
-                const path = (0, path_1.join)(dir, name);
-                // Assigned only once the file is actually open, so a path always names
-                // an fd rather than a file that failed to open.
-                const fd = (0, fs_1.openSync)(path, 'w');
-                this.capturedOutputPath = path;
-                this.capturedOutputFd = fd;
-            }
-            // Written synchronously so the file is complete the moment the batch ends,
-            // with no flush to sequence against the read that renders the fold.
-            while (written < bytes.length) {
-                written += (0, fs_1.writeSync)(this.capturedOutputFd, bytes, written);
-            }
-        }
-        catch (e) {
-            // This runs inside a stream 'data' handler, where a throw is an uncaught
-            // exception rather than something the orchestrator's try can see - so a
-            // full disk or a read-only data directory would take down a run that
-            // otherwise had nothing wrong with it. The capture is an optimization
-            // that the common path discards anyway, so give it up and put the bytes
-            // back on the terminal instead of losing both them and the run.
-            // Latch on a flag of its own rather than reusing the discard flag: that
-            // one makes `capture` return early, which would drop every later chunk
-            // on the floor - captured nowhere and printed nowhere.
-            this.capturedOutputFailed = true;
-            // Close the fd but keep the file. Whatever was written before the failure
-            // is still the head of the batch's log, which is where a compiler's first
-            // non-cascading errors live; unlinking it here would throw away the most
-            // useful bytes precisely when the disk is in trouble.
-            this.closeCapturedOutput();
-            // Forward only what did not reach the file, and do it before warning.
-            // `output.warn` writes to the terminal as well, so if that is the thing
-            // failing, the bytes this handler was handed must already be out - losing
-            // the warning is survivable, losing task output is what this path exists
-            // to prevent.
-            const unwritten = bytes.subarray(written);
-            if (unwritten.length > 0) {
-                output_1.output.writeTaskOutputChunk(unwritten, stream);
-            }
-            output_1.output.warn({
-                title: `Could not capture batch output for ${this.executorName}`,
-                bodyLines: [
-                    e.message,
-                    'Streaming the rest of it live instead; the fold holds what was captured first.',
-                ],
-            });
-        }
-    }
-    /**
-     * Path to the file holding everything held back from the live stream under
-     * log grouping, or undefined if nothing was captured. Used to render the whole
-     * batch as one fold, so output no task claimed is not lost.
-     *
-     * The file is deliberately left open rather than closed here. A worker's
-     * stdout can deliver after its exit event — which is what `getResults()`
-     * settles on — and leaving the fd open keeps such a chunk appending to this
-     * same file instead of minting a second numbered one that nothing cleans up.
-     * The caller reads the file once, synchronously, while rendering the fold, so
-     * anything arriving after that read is not shown; writes are unbuffered, so
-     * the read always sees a complete prefix of what has arrived by then.
-     */
-    getCapturedOutputPath() {
-        return this.capturedOutputPath;
-    }
-    /** Releases the capture file. Safe to call more than once. */
-    discardCapturedOutput() {
-        this.capturedOutputDiscarded = true;
-        this.releaseCapturedOutput();
-    }
-    /**
-     * Closes the fd and unlinks the file, leaving no path behind for a caller to
-     * read. Tolerates a partially-initialized capture, since it also runs when
-     * opening or writing the file is what failed.
-     */
-    releaseCapturedOutput() {
-        this.closeCapturedOutput();
-        if (this.capturedOutputPath) {
-            try {
-                (0, fs_1.rmSync)(this.capturedOutputPath, { force: true });
-            }
-            catch {
-                // `force` covers a missing file but not a locked one: on Windows an fd
-                // that failed to close still holds a share lock. This runs from
-                // `runBatch`'s finally, where throwing would replace the batch's real
-                // result with a cleanup error, so a stale file is the lesser outcome.
-            }
-            this.capturedOutputPath = undefined;
-        }
-    }
-    /** Closes the fd, keeping the file and its path readable. */
-    closeCapturedOutput() {
-        if (this.capturedOutputFd !== undefined) {
-            try {
-                (0, fs_1.closeSync)(this.capturedOutputFd);
-            }
-            catch { }
-            this.capturedOutputFd = undefined;
-        }
-    }
-    async getResults() {
-        return Promise.race([
-            new Promise((_, rej) => {
-                this.onExit((code) => {
-                    if (code !== 0) {
-                        rej(new Error(`"${this.executorName}" exited unexpectedly with code: ${code}`));
-                    }
-                });
-            }),
-            new Promise((res) => {
-                this.onBatchResults(res);
-            }),
-        ]);
-    }
-    send(message) {
-        if (this.childProcess.connected) {
-            this.childProcess.send(message);
-        }
-    }
-    kill(signal) {
-        if (this.childProcess?.pid) {
-            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
-        }
-        return Promise.resolve();
-    }
-}
-exports.BatchProcess = BatchProcess;
-BatchProcess.capturedOutputCount = 0;

package/dist/src/tasks-runner/running-tasks/node-child-process.d.ts

@@ -1,40 +0,0 @@
-import type { ChildProcess, Serializable } from 'child_process';
-import type { RunningTask } from './running-task';
-export declare class NodeChildProcessWithNonDirectOutput implements RunningTask {
-    private childProcess;
-    private terminalOutputChunks;
-    private joinedTerminalOutput;
-    private exitCallbacks;
-    private outputCallbacks;
-    private exitCode;
-    constructor(childProcess: ChildProcess, { streamOutput, prefix }: {
-        streamOutput: boolean;
-        prefix: string;
-    });
-    onExit(cb: (code: number, terminalOutput: string) => void): void;
-    onOutput(cb: (output: string) => void): void;
-    getResults(): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
-    send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals): Promise<void>;
-}
-export declare class NodeChildProcessWithDirectOutput implements RunningTask {
-    private childProcess;
-    private temporaryOutputPath;
-    private terminalOutput;
-    private exitCallbacks;
-    private exited;
-    private exitCode;
-    constructor(childProcess: ChildProcess, temporaryOutputPath: string);
-    send(message: Serializable): void;
-    onExit(cb: (code: number, signal: NodeJS.Signals) => void): void;
-    getResults(): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
-    waitForExit(): Promise<void>;
-    getTerminalOutput(): string;
-    kill(signal?: NodeJS.Signals): Promise<void>;
-}

package/dist/src/tasks-runner/running-tasks/node-child-process.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeChildProcessWithDirectOutput = exports.NodeChildProcessWithNonDirectOutput = void 0;
-const tslib_1 = require("tslib");
-const pc = tslib_1.__importStar(require("picocolors"));
-const fs_1 = require("fs");
-const stream_1 = require("stream");
-const native_1 = require("../../native");
-const exit_codes_1 = require("../../utils/exit-codes");
-const output_prefix_1 = require("./output-prefix");
-class NodeChildProcessWithNonDirectOutput {
-    constructor(childProcess, { streamOutput, prefix }) {
-        this.childProcess = childProcess;
-        this.terminalOutputChunks = [];
-        this.exitCallbacks = [];
-        this.outputCallbacks = [];
-        if (streamOutput) {
-            if (process.env.NX_PREFIX_OUTPUT === 'true') {
-                const color = (0, output_prefix_1.getColor)(prefix);
-                const prefixText = `${prefix}:`;
-                this.childProcess.stdout
-                    .pipe(logClearLineToPrefixTransformer(pc.bold(color(prefixText)) + ' '))
-                    .pipe((0, output_prefix_1.addPrefixTransformer)(pc.bold(color(prefixText))))
-                    .pipe(process.stdout);
-                this.childProcess.stderr
-                    .pipe(logClearLineToPrefixTransformer(color(prefixText) + ' '))
-                    .pipe((0, output_prefix_1.addPrefixTransformer)(color(prefixText)))
-                    .pipe(process.stderr);
-            }
-            else {
-                this.childProcess.stdout
-                    .pipe((0, output_prefix_1.addPrefixTransformer)())
-                    .pipe(process.stdout);
-                this.childProcess.stderr
-                    .pipe((0, output_prefix_1.addPrefixTransformer)())
-                    .pipe(process.stderr);
-            }
-        }
-        // 'close' (not 'exit') ensures stdio has drained before we join chunks (#35302).
-        this.childProcess.on('close', (code, signal) => {
-            if (code === null)
-                code = (0, exit_codes_1.signalToCode)(signal);
-            this.exitCode = code;
-            // Join once and cache before notifying exit callbacks
-            this.joinedTerminalOutput = this.terminalOutputChunks.join('');
-            this.terminalOutputChunks = [];
-            for (const cb of this.exitCallbacks) {
-                cb(code, this.joinedTerminalOutput);
-            }
-        });
-        // Re-emit any messages from the task process
-        this.childProcess.on('message', (message) => {
-            if (process.send) {
-                process.send(message);
-            }
-        });
-        this.childProcess.stdout.on('data', (chunk) => {
-            const output = chunk.toString();
-            this.terminalOutputChunks.push(output);
-            // Stream output to TUI via callbacks
-            for (const cb of this.outputCallbacks) {
-                cb(output);
-            }
-        });
-        this.childProcess.stderr.on('data', (chunk) => {
-            const output = chunk.toString();
-            this.terminalOutputChunks.push(output);
-            // Stream output to TUI via callbacks
-            for (const cb of this.outputCallbacks) {
-                cb(output);
-            }
-        });
-    }
-    onExit(cb) {
-        this.exitCallbacks.push(cb);
-    }
-    onOutput(cb) {
-        this.outputCallbacks.push(cb);
-    }
-    async getResults() {
-        if (typeof this.exitCode === 'number') {
-            return {
-                code: this.exitCode,
-                terminalOutput: this.joinedTerminalOutput ?? this.terminalOutputChunks.join(''),
-            };
-        }
-        return new Promise((res) => {
-            this.onExit((code, terminalOutput) => {
-                res({ code, terminalOutput });
-            });
-        });
-    }
-    send(message) {
-        if (this.childProcess.connected) {
-            this.childProcess.send(message);
-        }
-    }
-    kill(signal) {
-        if (this.childProcess?.pid) {
-            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
-        }
-        return Promise.resolve();
-    }
-}
-exports.NodeChildProcessWithNonDirectOutput = NodeChildProcessWithNonDirectOutput;
-/**
- * Prevents terminal escape sequence from clearing line prefix.
- */
-function logClearLineToPrefixTransformer(prefix) {
-    let prevChunk = null;
-    return new stream_1.Transform({
-        transform(chunk, _encoding, callback) {
-            if (prevChunk && prevChunk.toString() === '\x1b[2K') {
-                chunk = chunk.toString().replace(/\x1b\[1G/g, (m) => m + prefix);
-            }
-            this.push(chunk);
-            prevChunk = chunk;
-            callback();
-        },
-    });
-}
-class NodeChildProcessWithDirectOutput {
-    constructor(childProcess, temporaryOutputPath) {
-        this.childProcess = childProcess;
-        this.temporaryOutputPath = temporaryOutputPath;
-        this.exitCallbacks = [];
-        this.exited = false;
-        // Re-emit any messages from the task process
-        this.childProcess.on('message', (message) => {
-            if (process.send) {
-                process.send(message);
-            }
-        });
-        this.childProcess.on('exit', (code, signal) => {
-            if (code === null)
-                code = (0, exit_codes_1.signalToCode)(signal);
-            this.exited = true;
-            this.exitCode = code;
-            for (const cb of this.exitCallbacks) {
-                cb(code, signal);
-            }
-        });
-    }
-    send(message) {
-        if (this.childProcess.connected) {
-            this.childProcess.send(message);
-        }
-    }
-    onExit(cb) {
-        this.exitCallbacks.push(cb);
-    }
-    async getResults() {
-        if (!this.exited) {
-            await this.waitForExit();
-        }
-        const terminalOutput = this.getTerminalOutput();
-        return { code: this.exitCode, terminalOutput };
-    }
-    waitForExit() {
-        return new Promise((res) => {
-            this.onExit(() => res());
-        });
-    }
-    getTerminalOutput() {
-        this.terminalOutput ??= (0, fs_1.readFileSync)(this.temporaryOutputPath).toString();
-        return this.terminalOutput;
-    }
-    kill(signal) {
-        if (this.childProcess?.pid) {
-            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
-        }
-        return Promise.resolve();
-    }
-}
-exports.NodeChildProcessWithDirectOutput = NodeChildProcessWithDirectOutput;

package/dist/src/tasks-runner/running-tasks/noop-child-process.d.ts

@@ -1,16 +0,0 @@
-import { RunningTask } from './running-task';
-export declare class NoopChildProcess implements RunningTask {
-    private results;
-    constructor(results: {
-        code: number;
-        terminalOutput: string;
-    });
-    send(): void;
-    getResults(): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
-    kill(): void;
-    onExit(cb: (code: number, terminalOutput: string) => void): void;
-    onOutput(cb: (terminalOutput: string) => void): void;
-}

package/dist/src/tasks-runner/running-tasks/noop-child-process.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoopChildProcess = void 0;
-class NoopChildProcess {
-    constructor(results) {
-        this.results = results;
-    }
-    send() { }
-    async getResults() {
-        return this.results;
-    }
-    kill() {
-        return;
-    }
-    onExit(cb) {
-        cb(this.results.code, this.results.terminalOutput);
-    }
-    onOutput(cb) {
-        cb(this.results.terminalOutput);
-    }
-}
-exports.NoopChildProcess = NoopChildProcess;

package/dist/src/tasks-runner/running-tasks/output-prefix.d.ts

@@ -1,13 +0,0 @@
-import { Transform } from 'stream';
-export declare function getColor(projectName: string): import("picocolors/types").Formatter;
-/**
- * Formats a chunk by splitting it into lines and optionally prepending a prefix.
- * Returns an array of formatted line strings (including EOL).
- */
-export declare function formatPrefixedLines(chunk: string | Buffer, prefix?: string): string[];
-/**
- * Splits a chunk into lines, optionally prepends a prefix, and writes each
- * non-empty line to the given writable (defaults to `process.stdout`).
- */
-export declare function writePrefixedLines(chunk: string | Buffer, prefix?: string, writable?: NodeJS.WritableStream): void;
-export declare function addPrefixTransformer(prefix?: string): Transform;

package/dist/src/tasks-runner/running-tasks/output-prefix.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getColor = getColor;
-exports.formatPrefixedLines = formatPrefixedLines;
-exports.writePrefixedLines = writePrefixedLines;
-exports.addPrefixTransformer = addPrefixTransformer;
-const tslib_1 = require("tslib");
-const pc = tslib_1.__importStar(require("picocolors"));
-const os_1 = require("os");
-const stream_1 = require("stream");
-const colors = [
-    pc.green,
-    pc.greenBright,
-    pc.blue,
-    pc.blueBright,
-    pc.cyan,
-    pc.cyanBright,
-    pc.yellow,
-    pc.yellowBright,
-    pc.magenta,
-    pc.magentaBright,
-];
-function getColor(projectName) {
-    let code = 0;
-    for (let i = 0; i < projectName.length; ++i) {
-        code += projectName.charCodeAt(i);
-    }
-    const colorIndex = code % colors.length;
-    return colors[colorIndex];
-}
-/**
- * Formats a chunk by splitting it into lines and optionally prepending a prefix.
- * Returns an array of formatted line strings (including EOL).
- */
-function formatPrefixedLines(chunk, prefix) {
-    const lines = chunk.toString().split(/\r\n|[\n\v\f\r\x85\u2028\u2029]/g);
-    const result = [];
-    for (const line of lines) {
-        if (line) {
-            result.push(prefix ? prefix + ' ' + line + os_1.EOL : line + os_1.EOL);
-        }
-    }
-    return result;
-}
-/**
- * Splits a chunk into lines, optionally prepends a prefix, and writes each
- * non-empty line to the given writable (defaults to `process.stdout`).
- */
-function writePrefixedLines(chunk, prefix, writable = process.stdout) {
-    for (const line of formatPrefixedLines(chunk, prefix)) {
-        writable.write(line);
-    }
-}
-function addPrefixTransformer(prefix) {
-    return new stream_1.Transform({
-        transform(chunk, _encoding, callback) {
-            for (const line of formatPrefixedLines(chunk, prefix)) {
-                this.push(line);
-            }
-            callback();
-        },
-    });
-}

package/dist/src/tasks-runner/running-tasks/running-task.d.ts

@@ -1,11 +0,0 @@
-import type { Serializable } from 'child_process';
-export declare abstract class RunningTask {
-    abstract getResults(): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
-    abstract onExit(cb: (code: number) => void): void;
-    abstract kill(signal?: NodeJS.Signals): Promise<void> | void;
-    abstract onOutput?(cb: (output: string) => void): void;
-    abstract send?(message: Serializable): void;
-}