@rushstack/rush-http-build-cache-plugin 5.98.0 → 5.100.0-pr4132

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/d2/StdioLineTransform_d2f22c5a6ce4b53f293a12c214c78e9b

@@ -1,115 +0,0 @@
-75544cf5702ac0f336cbb6edb4e77f7d
-"use strict";
-// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
-// See LICENSE in the project root for license information.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StderrLineTransform = void 0;
-const node_core_library_1 = require("@rushstack/node-core-library");
-const TerminalTransform_1 = require("./TerminalTransform");
-/**
- * `StderrLineTransform` normalizes lines that mix characters from `stdout` and `stderr`,
- * so that each output line is routed entirely to `stdout` or `stderr`.
- *
- * @remarks
- * IMPORTANT: This transform assumes that its input has been normalized to use `"\n"` newlines.
- *
- * IMPORTANT: This transform does not produce realtime output, because lines are buffered
- * until a newline character is encountered.
- *
- * Suppose that a poorly behaved process produces output like this:
- *
- * ```ts
- * process.stderr.write('An error occurred, cleaning up');
- * process.stdout.write('.'); // (delay)
- * process.stdout.write('.'); // (delay)
- * process.stdout.write('.');
- * process.stdout.write('\n');
- * process.stderr.write('The process completed with errors\n');
- * ```
- *
- * When `stdout` and `stderr` are combined on the console, the mistake in the output would not be noticeable:
- * ```
- * An error occurred, cleaning up...
- * The process completed with errors
- * ```
- *
- * However, if we discard `stdout`, then `stderr` is malformed:
- * ```
- * An error occurred, cleaning upThe process completed with errors
- * ```
- *
- * Tooling scripts can introduce these sorts of problems via edge cases that are difficult to find and fix.
- *
- * `StderrLineTransform` normalizes the output so that if a combined line contains any `stderr` characters,
- * then the entire line is routed to `stderr`.  Later, if we discard `stdout`, then the output will
- * preserve the appropriate context:
- *
- * ```
- * An error occurred, cleaning up...
- * The process completed with errors
- * ```
- *
- * @privateRemarks
- * This class is experimental and marked as `@beta`.  The algorithm may need some fine-tuning, or there may
- * be better solutions to this problem.
- *
- * @beta
- */
-class StderrLineTransform extends TerminalTransform_1.TerminalTransform {
-    constructor(options) {
-        super(options);
-        this._accumulatedLine = '';
-        this._accumulatedStderr = false;
-        this.newline = node_core_library_1.Text.getNewline(options.newlineKind || node_core_library_1.NewlineKind.Lf);
-    }
-    onWriteChunk(chunk) {
-        if (chunk.text.indexOf('\r') >= 0) {
-            throw new Error('StderrLineTransform expects chunks with normalized newlines');
-        }
-        // After _newlineNormalizerTransform was applied, we can now assume that all newlines
-        // use the "\n" string
-        const text = chunk.text;
-        let startIndex = 0;
-        while (startIndex < text.length) {
-            if (chunk.kind === "E" /* TerminalChunkKind.Stderr */) {
-                this._accumulatedStderr = true;
-            }
-            const endIndex = text.indexOf('\n', startIndex);
-            if (endIndex < 0) {
-                // we did not find \n, so simply append
-                this._accumulatedLine += text.substring(startIndex);
-                break;
-            }
-            // append everything up to \n
-            this._accumulatedLine += text.substring(startIndex, endIndex);
-            this._processAccumulatedLine();
-            // skip the \n
-            startIndex = endIndex + 1;
-        }
-    }
-    onClose() {
-        if (this._accumulatedLine.length > 0) {
-            this._processAccumulatedLine();
-        }
-        this.autocloseDestination();
-    }
-    _processAccumulatedLine() {
-        this._accumulatedLine += this.newline;
-        if (this._accumulatedStderr) {
-            this.destination.writeChunk({
-                kind: "E" /* TerminalChunkKind.Stderr */,
-                text: this._accumulatedLine
-            });
-        }
-        else {
-            this.destination.writeChunk({
-                kind: "O" /* TerminalChunkKind.Stdout */,
-                text: this._accumulatedLine
-            });
-        }
-        this._accumulatedLine = '';
-        this._accumulatedStderr = false;
-    }
-}
-exports.StderrLineTransform = StderrLineTransform;
-//# sourceMappingURL=StdioLineTransform.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/d2/buffer_d24e8fbd314b1514e892b0037226d476

@@ -1,13 +0,0 @@
-d2bb78e5446d1606616eaac2c093270f
-'use strict'
-/* eslint-disable node/no-deprecated-api */
-module.exports = function (size) {
-  if (typeof Buffer.allocUnsafe === 'function') {
-    try {
-      return Buffer.allocUnsafe(size)
-    } catch (e) {
-      return new Buffer(size)
-    }
-  }
-  return new Buffer(size)
-}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/d2/neq_d231567796306add9d6c56edc5883cf8

@@ -1,4 +0,0 @@
-dfa93428b2368cff5aefd91d812bed06
-const compare = require('./compare')
-const neq = (a, b, loose) => compare(a, b, loose) !== 0
-module.exports = neq

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/d3/StreamCollator_d38868f25e405ca18337dd6c6c43bb7b

@@ -1,149 +0,0 @@
-2ce79f3931737b89f2166fd292c98b1a
-"use strict";
-// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
-// See LICENSE in the project root for license information.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamCollator = void 0;
-const node_core_library_1 = require("@rushstack/node-core-library");
-const CollatedWriter_1 = require("./CollatedWriter");
-const CollatedTerminal_1 = require("./CollatedTerminal");
-/**
- * A static class which manages the output of multiple threads.
- *
- * @beta
- */
-class StreamCollator {
-    constructor(options) {
-        this._taskNames = new Set();
-        this._writers = new Set();
-        // The writer whose output is being shown in realtime, or undefined if none
-        this._activeWriter = undefined;
-        // Writers that are not closed yet, and have never been active
-        this._openInactiveWriters = new Set();
-        // Writers that are now closed, but have accumulated buffered chunks, and have never been active
-        this._closedInactiveWriters = new Set();
-        this._preventReentrantCall = false;
-        this.destination = options.destination;
-        this.terminal = new CollatedTerminal_1.CollatedTerminal(this.destination);
-        this._onWriterActive = options.onWriterActive;
-    }
-    /**
-     * Returns the currently active `CollatedWriter`, or `undefined` if no writer
-     * is active yet.
-     */
-    get activeWriter() {
-        return this._activeWriter;
-    }
-    /**
-     * For diagnostic purposes, returns the {@link CollatedWriter.taskName} for the
-     * currently active writer, or an empty string if no writer is active.
-     */
-    get activeTaskName() {
-        if (this._activeWriter) {
-            return this._activeWriter.taskName;
-        }
-        return '';
-    }
-    /**
-     * The list of writers that have been registered by calling {@link StreamCollator.registerTask},
-     * in the order that they were registered.
-     */
-    get writers() {
-        return this._writers;
-    }
-    /**
-     * Registers a new task to be collated, and constructs a {@link CollatedWriter} object
-     * to receive its input.
-     */
-    registerTask(taskName) {
-        if (this._taskNames.has(taskName)) {
-            throw new Error('A task with that name has already been registered');
-        }
-        const writer = new CollatedWriter_1.CollatedWriter(taskName, this);
-        this._writers.add(writer);
-        this._taskNames.add(writer.taskName);
-        // When a task is initially registered, it is open and has not accumulated any buffered chunks
-        this._openInactiveWriters.add(writer);
-        if (this._activeWriter === undefined) {
-            // If there is no active writer, then the first one to be registered becomes active.
-            this._assignActiveWriter(writer);
-        }
-        return writer;
-    }
-    /** @internal */
-    _writerWriteChunk(writer, chunk, bufferedChunks) {
-        this._checkForReentrantCall();
-        if (this._activeWriter === undefined) {
-            // If no writer is currently active, then the first one to write something becomes active
-            this._assignActiveWriter(writer);
-        }
-        if (writer.isActive) {
-            this.destination.writeChunk(chunk);
-        }
-        else {
-            bufferedChunks.push(chunk);
-        }
-    }
-    /** @internal */
-    _writerClose(writer, bufferedChunks) {
-        this._checkForReentrantCall();
-        if (writer.isActive) {
-            writer._flushBufferedChunks();
-            this._activeWriter = undefined;
-            // If any buffered writers are already closed, activate them each immediately
-            // We copy the set, since _assignActiveWriter() will be deleting from it.
-            for (const closedInactiveWriter of [...this._closedInactiveWriters]) {
-                try {
-                    this._assignActiveWriter(closedInactiveWriter);
-                }
-                finally {
-                    this._activeWriter = undefined;
-                }
-            }
-            let writerToActivate = undefined;
-            // Try to activate a writer that already accumulated some data
-            for (const openInactiveWriter of this._openInactiveWriters) {
-                if (openInactiveWriter.bufferedChunks.length > 0) {
-                    writerToActivate = openInactiveWriter;
-                    break;
-                }
-            }
-            if (!writerToActivate) {
-                // Otherwise just take the first one
-                for (const openInactiveWriter of this._openInactiveWriters) {
-                    writerToActivate = openInactiveWriter;
-                    break;
-                }
-            }
-            if (writerToActivate) {
-                this._assignActiveWriter(writerToActivate);
-            }
-        }
-        else {
-            this._openInactiveWriters.delete(writer);
-            this._closedInactiveWriters.add(writer);
-        }
-    }
-    _assignActiveWriter(writer) {
-        this._activeWriter = writer;
-        this._closedInactiveWriters.delete(writer);
-        this._openInactiveWriters.delete(writer);
-        if (this._onWriterActive) {
-            this._preventReentrantCall = true;
-            try {
-                this._onWriterActive(writer);
-            }
-            finally {
-                this._preventReentrantCall = false;
-            }
-        }
-        writer._flushBufferedChunks();
-    }
-    _checkForReentrantCall() {
-        if (this._preventReentrantCall) {
-            throw new node_core_library_1.InternalError('Reentrant call to StreamCollator');
-        }
-    }
-}
-exports.StreamCollator = StreamCollator;
-//# sourceMappingURL=StreamCollator.js.map