@laurence79/wireit 0.14.13-shared-cache.0

package/lib/logging/quiet/writeover-line.js

@@ -0,0 +1,197 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DEBUG } from '../logger.js';
+import '../../util/dispose.js';
+// To prevent using the global console accidentally, we shadow it with
+// undefined
+const console = undefined;
+function markAsUsed(_) { }
+markAsUsed(console);
+class BaseWriteoverLine {
+    #updateInterval;
+    #disposed;
+    constructor(console) {
+        this._line = '';
+        this._targetFps = 60;
+        /**
+         * If true, we write over the previous line with a \r carriage return,
+         * otherwise we write a new line.
+         */
+        this._writeOver = !DEBUG;
+        this.#disposed = false;
+        this.#previousLineLength = 0;
+        this.console = console;
+    }
+    clearAndStopRendering() {
+        // Writeover the previous line and cancel the spinner interval.
+        if (this.#updateInterval !== undefined) {
+            clearInterval(this.#updateInterval);
+            this.#updateInterval = undefined;
+        }
+        if (this._line !== '') {
+            this._line = '';
+            this._writeLine('');
+        }
+    }
+    #previousLineLength;
+    _writeLine(line) {
+        if (!this._writeOver) {
+            if (line === '') {
+                return;
+            }
+            this.console.stderr.write(line);
+            this.console.stderr.write('\n');
+            return;
+        }
+        this.console.stderr.write(line);
+        const overflow = this.#previousLineLength - line.length;
+        if (overflow > 0) {
+            this.console.stderr.write(' '.repeat(overflow));
+        }
+        this.console.stderr.write('\r');
+        this.#previousLineLength = line.length;
+    }
+    /**
+     * Clears the line and stops the spinner, and returns a Disposable that, once
+     * disposed, will restore the line and restart the spinner (if the spinner
+     * was going when clearUntilDisposed() was called).
+     *
+     * Note that we don't expect writeoverLine.writeLine to be called while the
+     * Disposable is active, so we don't handle that case. We could, it just
+     * hasn't come up yet. We'd need to have an instance variable to count how
+     * many active Disposables there are, and only restore the line and restart
+     * the spinner when the last one is disposed. We'd also need to short circuit
+     * the logic in writeLine, and set aside the latest line to be written.
+     *
+     * Use like:
+     *
+     *     {
+     *       using _pause = writeoverLine.clearUntilDisposed();
+     *       // console.log, write to stdout and stderr, etc
+     *     }
+     *     // once the block ends, the writeoverLine is restored
+     */
+    clearUntilDisposed() {
+        // already cleared, nothing to do
+        if (this.#updateInterval === undefined) {
+            return undefined;
+        }
+        const line = this._line;
+        this.clearAndStopRendering();
+        return {
+            [Symbol.dispose]: () => {
+                this.updateStatusLine(line);
+            },
+        };
+    }
+    updateStatusLine(line) {
+        if (this.#disposed) {
+            return;
+        }
+        if (DEBUG) {
+            if (this._line !== line) {
+                // Ensure that every line is written immediately in debug mode
+                this.console.stderr.write(`  ${line}\n`);
+            }
+        }
+        this._line = line;
+        if (line === '') {
+            // Writeover the previous line and cancel the spinner interval.
+            if (this.#updateInterval !== undefined) {
+                clearInterval(this.#updateInterval);
+                this.#updateInterval = undefined;
+            }
+            this._writeLine('');
+            return;
+        }
+        if (this.#updateInterval !== undefined) {
+            // will render on next frame
+            return;
+        }
+        // render now, and then schedule future renders.
+        if (!DEBUG) {
+            this._update();
+        }
+        // schedule future renders so the spinner stays going
+        this.#updateInterval = setInterval(() => {
+            if (DEBUG) {
+                // We want to schedule an interval even in debug mode, so that tests
+                // will still fail if we don't clean it up properly, but we don't want
+                // to actually render anything here, since we render any new line
+                // the moment it comes in.
+                return;
+            }
+            this._update();
+        }, 1000 / this._targetFps);
+    }
+    [Symbol.dispose]() {
+        this.#disposed = true;
+        this.clearAndStopRendering();
+    }
+}
+/**
+ * Handles displaying a single line of status text, overwriting the previously
+ * written line, and displaying a spinner to indicate liveness.
+ */
+export class WriteoverLine extends BaseWriteoverLine {
+    #spinner = new Spinner();
+    #previouslyWrittenLine = undefined;
+    _update() {
+        if (this._line === this.#previouslyWrittenLine) {
+            // just write over the spinner
+            this.console.stderr.write(this.#spinner.nextFrame);
+            this.console.stderr.write('\r');
+            return;
+        }
+        this.#previouslyWrittenLine = this._line;
+        this._writeLine(`${this.#spinner.nextFrame} ${this._line}`);
+    }
+}
+/**
+ * Like WriteoverLine, but it updates much less frequently, just prints lines
+ * rather doing fancy writeover, doesn't draw a spinner, and stays silent
+ * if the status line line hasn't changed.
+ */
+export class CiWriter extends BaseWriteoverLine {
+    constructor(console) {
+        super(console);
+        this.previousLine = '';
+        // Don't write too much, no need to flood the CI logs.
+        this._targetFps = 1;
+        // GitHub seems to handle \r carraige returns the same as \n, but
+        // we don't want to rely on that. Just print status lines on new lines.
+        this._writeOver = false;
+    }
+    _update() {
+        if (this._line === this.previousLine) {
+            // nothing new to log
+            return;
+        }
+        this.previousLine = this._line;
+        this._writeLine(this._line);
+    }
+}
+const spinnerFrames = [
+    '⠋',
+    '⠙',
+    '⠹',
+    '⠸',
+    '⠼',
+    '⠴',
+    '⠦',
+    '⠧',
+    '⠇',
+    '⠏',
+];
+class Spinner {
+    #frame = 0;
+    get nextFrame() {
+        const frame = spinnerFrames[this.#frame];
+        this.#frame = (this.#frame + 1) % spinnerFrames.length;
+        return frame;
+    }
+}
+//# sourceMappingURL=writeover-line.js.map

package/lib/logging/quiet-logger.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CiWriter, WriteoverLine, } from './quiet/writeover-line.js';
+import { QuietRunLogger, noChange, nothing } from './quiet/run-tracker.js';
+// To prevent using the global console accidentally, we shadow it with
+// undefined
+const console = undefined;
+function markAsUsed(_) { }
+markAsUsed(console);
+/**
+ * A {@link Logger} that prints less to the console.
+ *
+ * While running, it prints a single line of status text with information about
+ * how the run is progressing, as well as emitting errors as they happen,
+ * and any output from services or the root script.
+ *
+ * When the run is complete, it prints a one line summary of the results.
+ */
+export class QuietLogger {
+    #runTracker;
+    #rootPackage;
+    #statusLineWriter;
+    constructor(rootPackage, ourConsole, statusLineWriter) {
+        this.#rootPackage = rootPackage;
+        this.#statusLineWriter = statusLineWriter ?? new WriteoverLine(ourConsole);
+        this.#runTracker = new QuietRunLogger(this.#rootPackage, this.#statusLineWriter, ourConsole);
+        this.console = ourConsole;
+    }
+    printMetrics() {
+        this.#statusLineWriter.clearAndStopRendering();
+        this.#runTracker.printSummary();
+    }
+    log(event) {
+        if (event.type === 'info' && event.detail === 'watch-run-start') {
+            this.#runTracker = this.#runTracker.makeInstanceForNextWatchRun();
+        }
+        const line = this.#runTracker.getUpdatedMessageAfterEvent(event);
+        if (line === noChange) {
+            // nothing to do
+        }
+        else if (line === nothing) {
+            this.#statusLineWriter.clearAndStopRendering();
+        }
+        else {
+            this.#statusLineWriter.updateStatusLine(line);
+        }
+        if (event.type === 'info' && event.detail === 'watch-run-end') {
+            this.printMetrics();
+        }
+    }
+    getWatchLogger() {
+        // QuietLogger doesn't need the screen-clearning behavior of the watch
+        // logger, since in successful cases it only prints one line of output,
+        // and in failure cases it can be nice to keep the old output around.
+        return this;
+    }
+    [Symbol.dispose]() {
+        this.#statusLineWriter[Symbol.dispose]();
+        this.#runTracker[Symbol.dispose]();
+        this.console[Symbol.dispose]();
+    }
+}
+/**
+ * A QuietLogger that is intended to be used in CI environments and other
+ * non-interactive environments.
+ *
+ * Doesn't use a spinner, updates less often, and doesn't use '/r' to writeover
+ * the previous line.
+ */
+export class QuietCiLogger extends QuietLogger {
+    constructor(rootPackage, ourConsole) {
+        super(rootPackage, ourConsole, new CiWriter(ourConsole));
+    }
+}
+//# sourceMappingURL=quiet-logger.js.map

package/lib/logging/simple-logger.js

@@ -0,0 +1,296 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as pathlib from 'path';
+import { unreachable } from '../util/unreachable.js';
+import { DiagnosticPrinter } from '../error.js';
+import { createRequire } from 'module';
+import { WatchLogger } from './watch-logger.js';
+const getWireitVersion = (() => {
+    let version;
+    return () => {
+        if (version === undefined) {
+            version = createRequire(import.meta.url)('../../package.json').version;
+        }
+        return version;
+    };
+})();
+// To prevent using the global console accidentally, we shadow it with
+// undefined
+const console = undefined;
+function markAsUsed(_) { }
+markAsUsed(console);
+/**
+ * Simple {@link Logger} which logs to stdout and stderr.
+ */
+export class SimpleLogger {
+    #rootPackageDir;
+    #diagnosticPrinter;
+    /**
+     * @param rootPackage The npm package directory that the root script being
+     * executed belongs to.
+     */
+    constructor(rootPackage, ourConsole) {
+        this.#rootPackageDir = rootPackage;
+        this.#diagnosticPrinter = new DiagnosticPrinter(this.#rootPackageDir);
+        this.console = ourConsole;
+    }
+    log(event) {
+        const type = event.type;
+        const label = labelForScript(this.#rootPackageDir, event.script);
+        const prefix = label !== '' ? ` [${label}]` : '';
+        switch (type) {
+            default: {
+                throw new Error(`Unknown event type: ${unreachable(type)}`);
+            }
+            case 'success': {
+                const reason = event.reason;
+                switch (reason) {
+                    default: {
+                        throw new Error(`Unknown success reason: ${unreachable(reason)}`);
+                    }
+                    case 'exit-zero': {
+                        this.console.log(`✅${prefix} Executed successfully`);
+                        break;
+                    }
+                    case 'no-command': {
+                        this.console.log(`✅${prefix} No command to execute`);
+                        break;
+                    }
+                    case 'fresh': {
+                        this.console.log(`✅${prefix} Already fresh`);
+                        break;
+                    }
+                    case 'cached': {
+                        this.console.log(`✅${prefix} Restored from cache`);
+                        break;
+                    }
+                }
+                break;
+            }
+            case 'failure': {
+                if (event.logged) {
+                    return;
+                }
+                event.logged = true;
+                const reason = event.reason;
+                switch (reason) {
+                    default: {
+                        throw new Error(`Unknown failure reason: ${unreachable(reason)}`);
+                    }
+                    case 'launched-incorrectly': {
+                        this.console.error(`❌${prefix} wireit must be launched with "npm run" or a compatible command.`);
+                        this.console.error(`    More info: ${event.detail}`);
+                        break;
+                    }
+                    case 'missing-package-json': {
+                        this.console.error(`❌${prefix} No package.json was found in ${event.script.packageDir}`);
+                        break;
+                    }
+                    case 'invalid-json-syntax': {
+                        for (const diagnostic of event.diagnostics) {
+                            this.console.error(this.#diagnosticPrinter.print(diagnostic));
+                        }
+                        break;
+                    }
+                    case 'no-scripts-in-package-json': {
+                        this.console.error(`❌${prefix} No "scripts" section defined in package.json in ${event.script.packageDir}`);
+                        break;
+                    }
+                    case 'script-not-found':
+                    case 'wireit-config-but-no-script':
+                    case 'duplicate-dependency':
+                    case 'script-not-wireit':
+                    case 'invalid-config-syntax':
+                    case 'cycle':
+                    case 'dependency-on-missing-package-json':
+                    case 'dependency-on-missing-script': {
+                        this.console.error(this.#diagnosticPrinter.print(event.diagnostic));
+                        break;
+                    }
+                    case 'invalid-usage': {
+                        this.console.error(`❌${prefix} Invalid usage: ${event.message}`);
+                        break;
+                    }
+                    case 'exit-non-zero': {
+                        this.console.error(`❌${prefix} Failed with exit status ${event.status}`);
+                        break;
+                    }
+                    case 'signal': {
+                        this.console.error(`❌${prefix} Failed with signal ${event.signal}`);
+                        break;
+                    }
+                    case 'spawn-error': {
+                        this.console.error(`❌${prefix} Process spawn error: ${event.message}`);
+                        break;
+                    }
+                    case 'start-cancelled': {
+                        // The script never started. We don't really need to log this, it's
+                        // fairly noisy. Maybe in a verbose mode.
+                        break;
+                    }
+                    case 'failed-previous-watch-iteration': {
+                        this.console.error(`❌${prefix} Failed on previous watch iteration`);
+                        break;
+                    }
+                    case 'killed': {
+                        this.console.error(`💀${prefix} Killed`);
+                        break;
+                    }
+                    case 'unknown-error-thrown': {
+                        this.console.error(`❌${prefix} Internal error! Please file a bug at https://github.com/google/wireit/issues/new, mention this message, that you encountered it in wireit version ${getWireitVersion()}, and give information about your package.json files.\n    Unknown error thrown: ${String(event.error)}`);
+                        const maybeError = event.error;
+                        if (maybeError?.stack) {
+                            this.console.error(maybeError.stack);
+                        }
+                        break;
+                    }
+                    case 'dependency-invalid': {
+                        this.console.error(`❌${prefix} Depended, perhaps indirectly, on ${labelForScript(this.#rootPackageDir, event.dependency)} which could not be validated. Please file a bug at https://github.com/google/wireit/issues/new, mention this message, that you encountered it in wireit version ${getWireitVersion()}, and give information about your package.json files.`);
+                        break;
+                    }
+                    case 'service-exited-unexpectedly': {
+                        this.console.error(`❌${prefix} Service exited unexpectedly`);
+                        break;
+                    }
+                    case 'input-file-deleted-unexpectedly': {
+                        for (const filePath of event.filePaths) {
+                            this.console.error(`❌${prefix} Input file "${filePath}" was deleted unexpectedly. Is another process writing to the same location?`);
+                        }
+                        break;
+                    }
+                    case 'output-file-deleted-unexpectedly': {
+                        for (const filePath of event.filePaths) {
+                            this.console.error(`❌${prefix} Output file "${filePath}" was deleted unexpectedly. Is another process writing to the same location?`);
+                        }
+                        break;
+                    }
+                    case 'aborted':
+                    case 'dependency-service-exited-unexpectedly': {
+                        // These event isn't very useful to log, because they are downstream
+                        // of failures that already get reported elsewhere.
+                        break;
+                    }
+                }
+                break;
+            }
+            case 'output': {
+                const stream = event.stream;
+                switch (stream) {
+                    default: {
+                        throw new Error(`Unknown output stream: ${unreachable(stream)}`);
+                    }
+                    // TODO(aomarks) More advanced handling of output streams so that
+                    // output isn't simply interweaved.
+                    case 'stdout': {
+                        this.console.stdout.write(event.data);
+                        break;
+                    }
+                    case 'stderr': {
+                        this.console.stderr.write(event.data);
+                        break;
+                    }
+                }
+                break;
+            }
+            case 'info': {
+                const detail = event.detail;
+                switch (detail) {
+                    default: {
+                        throw new Error(`Unknown info event detail: ${unreachable(detail)}`);
+                    }
+                    case 'running': {
+                        this.console.log(`🏃${prefix} Running command "${event.script.command?.value ?? ''}"`);
+                        break;
+                    }
+                    case 'locked': {
+                        this.console.log(`💤${prefix} Waiting for another process which is already running this script.`);
+                        break;
+                    }
+                    case 'output-modified': {
+                        this.console.log(`ℹ️${prefix} Output files were modified since the previous run.`);
+                        break;
+                    }
+                    case 'watch-run-start': {
+                        if (process.stdout.isTTY) {
+                            // If we are in an interactive terminal (TTY), reset it before
+                            // each run. This is helpful because it means only the output for
+                            // the current build is visible. This is exactly the same as what
+                            // "tsc --watch" does.
+                            //
+                            // This string is the ESC character (ASCII \x1B) followed by "c",
+                            // which is the VT100 reset sequence, supported by most terminals:
+                            // https://www2.ccs.neu.edu/research/gpc/VonaUtils/vona/terminal/vtansi.htm#:~:text=Reset%20Device
+                            this.console.log('\x1Bc');
+                        }
+                        break;
+                    }
+                    case 'watch-run-end': {
+                        this.console.log(`👀${prefix} Watching for file changes`);
+                        break;
+                    }
+                    case 'cache-info': {
+                        this.console.log(`ℹ️${prefix} ${event.message}`);
+                        break;
+                    }
+                    case 'service-process-started': {
+                        this.console.log(`⬆️${prefix} Service starting...`);
+                        break;
+                    }
+                    case 'service-ready': {
+                        this.console.log(`⬆️${prefix} Service ready`);
+                        break;
+                    }
+                    case 'service-stopped': {
+                        this.console.log(`⬇️${prefix} Service stopped`);
+                        break;
+                    }
+                    case 'analysis-started':
+                    case 'analysis-completed': {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    printMetrics() {
+        // printMetrics() not used in default-logger.
+    }
+    getWatchLogger() {
+        return new WatchLogger(this);
+    }
+    [Symbol.dispose]() {
+        this.console[Symbol.dispose]();
+    }
+}
+/**
+ * Make a concise label for a script, or for just a package if we don't know
+ * the script name. If the package is different to the root package, it is
+ * disambiguated with a relative path.
+ */
+export function labelForScript(rootPackageDir, script) {
+    const packageDir = script.packageDir;
+    const scriptName = 'name' in script ? script.name : undefined;
+    if (packageDir !== rootPackageDir) {
+        const relativePackageDir = pathlib
+            .relative(rootPackageDir, script.packageDir)
+            // Normalize to posix-style forward-slashes as the path separator, even
+            // on Windows which usually uses back-slashes. This way labels match the
+            // syntax used in the package.json dependency specifiers (which are
+            // already posix style).
+            .replace(pathlib.sep, pathlib.posix.sep);
+        if (scriptName !== undefined) {
+            return `${relativePackageDir}:${scriptName}`;
+        }
+        else {
+            return relativePackageDir;
+        }
+    }
+    else if (scriptName !== undefined) {
+        return scriptName;
+    }
+    return '';
+}
+//# sourceMappingURL=simple-logger.js.map

package/lib/logging/watch-logger.js

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// To prevent using the global console accidentally, we shadow it with
+// undefined
+const console = undefined;
+function markAsUsed(_) { }
+markAsUsed(console);
+/**
+ * A logger for watch mode that avoids useless output.
+ */
+export class WatchLogger {
+    #actualLogger;
+    #iterationBuffer = [];
+    #iterationIsInteresting = /* The first iteration is always interesting. */ true;
+    constructor(actualLogger) {
+        this.#actualLogger = actualLogger;
+        this.console = actualLogger.console;
+    }
+    log(event) {
+        if (this.#iterationIsInteresting) {
+            // This iteration previously had an interesting event (or it's the very
+            // first one, which we always show).
+            this.#actualLogger.log(event);
+            this.#actualLogger.printMetrics();
+            if (this.#isWatchRunEnd(event)) {
+                this.#iterationIsInteresting = false;
+            }
+        }
+        else if (this.#isWatchRunEnd(event)) {
+            // We finished a watch iteration and nothing interesting ever happened.
+            // Discard the buffer.
+            this.#iterationBuffer.length = 0;
+        }
+        else if (this.#isInteresting(event)) {
+            // The first interesting event of the iteration. Flush the buffer and log
+            // everything from now until the next iteration.
+            while (this.#iterationBuffer.length > 0) {
+                this.#actualLogger.log(this.#iterationBuffer.shift());
+            }
+            this.#actualLogger.log(event);
+            this.#iterationIsInteresting = true;
+        }
+        else {
+            // An uninteresting event in a thus far uninteresting iteration.
+            this.#iterationBuffer.push(event);
+        }
+    }
+    printMetrics() {
+        // printMetrics() not used in watch-logger.
+    }
+    #isInteresting(event) {
+        const code = event.type === 'output'
+            ? event.stream
+            : event.type === 'info'
+                ? event.detail
+                : event.reason;
+        switch (code) {
+            case 'fresh':
+            case 'no-command':
+            case 'failed-previous-watch-iteration':
+            case 'watch-run-start':
+            case 'start-cancelled':
+            case 'locked':
+            case 'analysis-completed': {
+                return false;
+            }
+        }
+        return true;
+    }
+    #isWatchRunEnd(event) {
+        return event.type === 'info' && event.detail === 'watch-run-end';
+    }
+    [Symbol.dispose]() {
+        this.#actualLogger[Symbol.dispose]();
+        this.console[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=watch-logger.js.map