@rushstack/rush-http-build-cache-plugin 5.92.0

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

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,149 @@
+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