@laurence79/wireit 0.14.13-shared-cache.0

package/lib/language-server.js

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// This is where the bulk of the work of the extension happens. This file
+// runs in its own process, and communicates with the main process via
+// node IPC.
+// jsonc-parser often uses 'any' when they mean 'unknown'. We might want to
+// declare our own types for them, but for now, we'll just quiet down eslint.
+import { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, CodeActionKind, } from 'vscode-languageserver/node';
+import * as url from 'url';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { inspect } from 'util';
+import { IdeAnalyzer } from './ide.js';
+const ideAnalyzer = new IdeAnalyzer();
+const connection = createConnection(ProposedFeatures.all);
+connection.onInitialize((init) => {
+    const workspacePaths = [];
+    for (const folder of init.workspaceFolders ?? []) {
+        workspacePaths.push(url.fileURLToPath(folder.uri));
+    }
+    ideAnalyzer.setWorkspaceRoots(workspacePaths);
+    const result = {
+        capabilities: {
+            textDocumentSync: TextDocumentSyncKind.Incremental,
+            // If we add any new features, we'll generally need to declare them
+            // here.
+            codeActionProvider: {
+                codeActionKinds: [
+                    CodeActionKind.QuickFix,
+                    CodeActionKind.RefactorExtract,
+                ],
+            },
+            definitionProvider: true,
+            referencesProvider: true,
+            completionProvider: {
+                // We don't have more information later, so don't bother asking.
+                resolveProvider: false,
+                completionItem: {},
+                triggerCharacters: ['"', ':', '/'],
+            },
+        },
+    };
+    return result;
+});
+function log(...values) {
+    for (const value of values) {
+        let message;
+        if (typeof value === 'string') {
+            message = value;
+        }
+        else {
+            message = inspect(value, { depth: 4 });
+        }
+        connection.console.log(message);
+    }
+}
+// So that we can just console.log and console.error as usual.
+console.log = log;
+console.error = log;
+const documents = new TextDocuments(TextDocument);
+let requestIdCounter = 0;
+const getAndSendDiagnostics = async () => {
+    requestIdCounter++;
+    const requestId = requestIdCounter;
+    const diagnosticsByFile = await ideAnalyzer.getDiagnostics();
+    if (requestId !== requestIdCounter) {
+        return; // another request has been made since this one
+    }
+    for (const path of ideAnalyzer.openFiles) {
+        const diagnostics = diagnosticsByFile.get(path) ?? [];
+        void connection.sendDiagnostics({
+            uri: url.pathToFileURL(path).toString(),
+            diagnostics: [...diagnostics],
+        });
+    }
+};
+const updateOpenFile = (document) => {
+    if (document.languageId !== 'json') {
+        return;
+    }
+    const path = url.fileURLToPath(document.uri);
+    if (!path.endsWith('package.json')) {
+        return;
+    }
+    const contents = document.getText();
+    ideAnalyzer.setOpenFileContents(path, contents);
+    void getAndSendDiagnostics();
+};
+documents.onDidOpen((event) => {
+    updateOpenFile(event.document);
+});
+documents.onDidChangeContent((change) => {
+    updateOpenFile(change.document);
+});
+documents.onDidClose((change) => {
+    const path = url.fileURLToPath(change.document.uri);
+    ideAnalyzer.closeFile(path);
+    void getAndSendDiagnostics();
+    // Clear diagnostics for closed file.
+    void connection.sendDiagnostics({
+        uri: change.document.uri,
+        diagnostics: [],
+    });
+});
+connection.onCodeAction(async (params) => {
+    const document = documents.get(params.textDocument.uri);
+    if (document === undefined) {
+        return [];
+    }
+    const path = url.fileURLToPath(document.uri);
+    const actions = await ideAnalyzer.getCodeActions(path, params.range);
+    return actions;
+});
+connection.onDefinition(async (params) => {
+    const path = url.fileURLToPath(params.textDocument.uri);
+    const position = params.position;
+    return ideAnalyzer.getDefinition(path, position);
+});
+connection.onReferences(async (params) => {
+    // TODO: handle params.context.includeDeclaration
+    const path = url.fileURLToPath(params.textDocument.uri);
+    const position = params.position;
+    return ideAnalyzer.findAllReferences(path, position);
+});
+connection.onCompletion(async (params) => {
+    const path = url.fileURLToPath(params.textDocument.uri);
+    const position = params.position;
+    return ideAnalyzer.getCompletions(path, position);
+});
+// Actually start listening
+documents.listen(connection);
+connection.listen();
+//# sourceMappingURL=language-server.js.map

package/lib/logging/combination-logger.js

@@ -0,0 +1,41 @@
+/**
+ * @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 {@link Logger} that logs to multiple loggers.
+ */
+export class CombinationLogger {
+    #loggers;
+    constructor(loggers, console) {
+        this.console = console;
+        this.#loggers = loggers;
+    }
+    log(event) {
+        for (const logger of this.#loggers) {
+            logger.log(event);
+        }
+    }
+    printMetrics() {
+        for (const logger of this.#loggers) {
+            logger.printMetrics?.();
+        }
+    }
+    getWatchLogger() {
+        const watchLoggers = this.#loggers.map((logger) => logger.getWatchLogger?.() ?? logger);
+        return new CombinationLogger(watchLoggers, this.console);
+    }
+    [Symbol.dispose]() {
+        for (const logger of this.#loggers) {
+            logger[Symbol.dispose]?.();
+        }
+        this.console[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=combination-logger.js.map

package/lib/logging/debug-logger.js

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SimpleLogger } from './simple-logger.js';
+import { inspect } from 'node:util';
+// To prevent using the global console accidentally, we shadow it with
+// undefined
+const console = undefined;
+function markAsUsed(_) { }
+markAsUsed(console);
+/**
+ * A {@link Logger} for logging debug information, mainly in tests.
+ */
+export class DebugLogger extends SimpleLogger {
+    log(event) {
+        switch (event.type) {
+            case 'info':
+                this.console.log(`<info> ${event.detail}`);
+                break;
+            case 'failure':
+                this.console.log(`<failure> ${event.reason}`);
+                break;
+            case 'output':
+                // too verbose, log nothing
+                return;
+            case 'success':
+                this.console.log(`<success> ${event.reason}`);
+                break;
+            default: {
+                const never = event;
+                throw new Error(`Unknown event type: ${inspect(never)}`);
+            }
+        }
+        super.log(event);
+    }
+    [Symbol.dispose]() {
+        super[Symbol.dispose]();
+        this.console[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=debug-logger.js.map

package/lib/logging/logger.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import '../util/dispose.js';
+import { Console as NodeConsole } from 'node:console';
+// To prevent using the global console accidentally, we shadow it with
+// undefined
+const console = undefined;
+function markAsUsed(_) { }
+markAsUsed(console);
+export class Console extends NodeConsole {
+    #closeStreams;
+    #closed = false;
+    constructor(stdout, stderr, closeStreams = false) {
+        super(stdout, stderr);
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.#closeStreams = closeStreams;
+    }
+    [Symbol.dispose]() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        if (this.#closeStreams) {
+            this.stdout.end();
+            this.stderr.end();
+        }
+    }
+}
+/**
+ * When true, we're debugging the logger itself, so a logger should log with
+ * more verbosity, and not overwrite previously written lines.
+ */
+export const DEBUG = Boolean(process.env['WIREIT_DEBUG_LOGGER']);
+//# sourceMappingURL=logger.js.map

package/lib/logging/metrics-logger.js

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { hrtime } from 'process';
+import { SimpleLogger } from './simple-logger.js';
+// To prevent using the global console accidentally, we shadow it with
+// undefined
+const console = undefined;
+function markAsUsed(_) { }
+markAsUsed(console);
+/**
+ * A {@link Logger} that keeps track of metrics.
+ */
+export class MetricsLogger extends SimpleLogger {
+    #startTime = hrtime();
+    #metrics = [
+        {
+            name: 'Success',
+            // 'no-command' is technically a success, but we don't want to count it as
+            // a success for this metric because nothing was actually run.
+            matches: (e) => e.type === 'success' && e.reason !== 'no-command',
+            count: 0,
+        },
+        {
+            name: 'Ran',
+            matches: (e) => e.type === 'success' && e.reason === 'exit-zero',
+            count: 0,
+        },
+        {
+            name: 'Skipped (fresh)',
+            matches: (e) => e.type === 'success' && e.reason === 'fresh',
+            count: 0,
+        },
+        {
+            name: 'Restored from cache',
+            matches: (e) => e.type === 'success' && e.reason === 'cached',
+            count: 0,
+        },
+    ];
+    /**
+     * @param rootPackage The npm package directory that the root script being
+     * executed belongs to.
+     */
+    constructor(rootPackage, console) {
+        super(rootPackage, console);
+    }
+    /**
+     * Update relevant metrics for an event and pass it up to the parent logger.
+     */
+    log(event) {
+        // When in watch mode, metrics should reset at the start of each run.
+        if (event.type === 'info' && event.detail === 'watch-run-start') {
+            this.#resetMetrics();
+        }
+        this.#updateMetrics(event);
+        super.log(event);
+    }
+    /**
+     * Log the current metrics and reset the state of each metric.
+     */
+    printMetrics() {
+        const successes = this.#metrics[0].count ?? 0;
+        if (!successes) {
+            this.#resetMetrics();
+            return;
+        }
+        const elapsed = this.#getElapsedTime();
+        const nameOffset = 20;
+        const out = [
+            `🏁 [metrics] Executed ${successes} script(s) in ${elapsed} seconds`,
+        ];
+        for (const metric of this.#metrics.slice(1)) {
+            const name = metric.name.padEnd(nameOffset);
+            const count = metric.count;
+            const percent = this.#calculatePercentage(count, successes);
+            out.push(`\t${name}: ${count} (${percent}%)`);
+        }
+        this.console.log(out.join('\n'));
+        this.#resetMetrics();
+    }
+    #updateMetrics(event) {
+        for (const metric of this.#metrics) {
+            if (metric.matches(event)) {
+                metric.count++;
+            }
+        }
+    }
+    #resetMetrics() {
+        this.#startTime = hrtime();
+        for (const metric of this.#metrics) {
+            metric.count = 0;
+        }
+    }
+    #getElapsedTime() {
+        const [seconds, nanoseconds] = hrtime(this.#startTime);
+        const time = seconds + nanoseconds / 1e9;
+        return time.toFixed(2);
+    }
+    #calculatePercentage(numerator, denominator) {
+        if (denominator === 0) {
+            return 0;
+        }
+        return Math.floor((numerator / denominator) * 100);
+    }
+}
+//# sourceMappingURL=metrics-logger.js.map