@laurence79/wireit 0.14.13-shared-cache.0

package/lib/script-child-process.js

@@ -0,0 +1,270 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as pathlib from 'path';
+import { spawn } from 'child_process';
+import { augmentProcessEnvSafelyIfOnWindows, IS_WINDOWS, } from './util/windows.js';
+import { Deferred } from './util/deferred.js';
+/**
+ * The PATH environment variable of this process, minus all of the leading
+ * "node_modules/.bin" entries that the incoming "npm run" command already set.
+ *
+ * We want full control over which "node_modules/.bin" paths are in the PATH of
+ * the processes we spawn, so that cross-package dependencies act as though we
+ * are running "npm run" with each package as the cwd.
+ *
+ * We only need to do this once per Wireit process, because process.env never
+ * changes.
+ */
+const PATH_ENV_SUFFIX = (() => {
+    const path = process.env.PATH ?? '';
+    // Note the PATH delimiter is platform-dependent.
+    const entries = path.split(pathlib.delimiter);
+    const nodeModulesBinSuffix = pathlib.join('node_modules', '.bin');
+    const endOfNodeModuleBins = entries.findIndex((entry) => !entry.endsWith(nodeModulesBinSuffix));
+    return entries.slice(endOfNodeModuleBins).join(pathlib.delimiter);
+})();
+/**
+ * A child process spawned during execution of a script.
+ */
+export class ScriptChildProcess {
+    #script;
+    #child;
+    #started;
+    #completed;
+    #state;
+    get stdout() {
+        return this.#child.stdout;
+    }
+    get stderr() {
+        return this.#child.stderr;
+    }
+    constructor(script) {
+        this.#started = new Deferred();
+        this.#completed = new Deferred();
+        this.#state = 'starting';
+        /**
+         * Resolves when this process starts
+         */
+        this.started = this.#started.promise;
+        /**
+         * Resolves when this child process ends.
+         */
+        this.completed = this.#completed.promise;
+        // Copy only the fields we actually require from the script config, because
+        // the full script config contains references to the full config, which we
+        // want to allow to be garbage-collected across watch iterations.
+        this.#script = {
+            packageDir: script.packageDir,
+            name: script.name,
+            command: script.command,
+            extraArgs: script.extraArgs,
+            env: script.env,
+        };
+        // TODO(aomarks) Update npm_ environment variables to reflect the new
+        // package.
+        this.#child = spawn(this.#script.command.value, this.#script.extraArgs, {
+            cwd: this.#script.packageDir,
+            // Conveniently, "shell:true" has the same shell-selection behavior as
+            // "npm run", where on macOS and Linux it is "sh", and on Windows it is
+            // %COMSPEC% || "cmd.exe".
+            //
+            // References:
+            //   https://nodejs.org/api/child_process.html#child_processspawncommand-args-options
+            //   https://nodejs.org/api/child_process.html#default-windows-shell
+            //   https://github.com/npm/run-script/blob/a5b03bdfc3a499bf7587d7414d5ea712888bfe93/lib/make-spawn-args.js#L11
+            shell: true,
+            env: augmentProcessEnvSafelyIfOnWindows({
+                FORCE_COLOR: process.stdout.isTTY && process.env.FORCE_COLOR === undefined
+                    ? 'true'
+                    : process.env.FORCE_COLOR,
+                PATH: this.#pathEnvironmentVariable,
+                ...this.#script.env,
+            }),
+            // Set "detached" on Linux and macOS so that we create a new process
+            // group, instead of being added to the process group for this Wireit
+            // process.
+            //
+            // We need a new process group so that we can use "kill(-pid)" to kill all
+            // of the processes in the process group, instead of just the group leader
+            // "sh" process. "sh" does not forward signals to child processes, so a
+            // regular "kill(pid)" would not kill the actual process we care about.
+            //
+            // On Windows this works differently, and we use the "\t" flag to
+            // "taskkill" to kill child processes. However, if we do set "detached" on
+            // Windows, it causes the child process to open in a new terminal window,
+            // which we don't want.
+            detached: !IS_WINDOWS,
+        });
+        this.#child.on('spawn', () => {
+            switch (this.#state) {
+                case 'starting': {
+                    this.#started.resolve({ ok: true, value: undefined });
+                    this.#state = 'started';
+                    break;
+                }
+                case 'killing': {
+                    this.#started.resolve({ ok: true, value: undefined });
+                    // We received a kill request while we were still starting. Kill now
+                    // that we're started.
+                    this.#actuallyKill();
+                    break;
+                }
+                case 'started':
+                case 'stopped': {
+                    const exception = new Error(`Internal error: Expected ScriptChildProcessState ` +
+                        `to be "started" or "killing" but was "${this.#state}"`);
+                    this.#started.reject(exception);
+                    this.#completed.reject(exception);
+                    break;
+                }
+                default: {
+                    const never = this.#state;
+                    const exception = new Error(`Internal error: unexpected ScriptChildProcessState: ${String(never)}`);
+                    this.#started.reject(exception);
+                    this.#completed.reject(exception);
+                }
+            }
+        });
+        this.#child.on('error', (error) => {
+            const result = {
+                ok: false,
+                error: {
+                    script,
+                    type: 'failure',
+                    reason: 'spawn-error',
+                    message: error.message,
+                },
+            };
+            this.#started.resolve(result);
+            this.#completed.resolve(result);
+            this.#state = 'stopped';
+        });
+        this.#child.on('close', (status, signal) => {
+            if (this.#state === 'killing') {
+                this.#completed.resolve({
+                    ok: false,
+                    error: {
+                        script,
+                        type: 'failure',
+                        reason: 'killed',
+                    },
+                });
+            }
+            else if (signal !== null) {
+                this.#completed.resolve({
+                    ok: false,
+                    error: {
+                        script,
+                        type: 'failure',
+                        reason: 'signal',
+                        signal,
+                    },
+                });
+            }
+            else if (status !== 0) {
+                this.#completed.resolve({
+                    ok: false,
+                    error: {
+                        script,
+                        type: 'failure',
+                        reason: 'exit-non-zero',
+                        // status should only ever be null if signal was not null, but
+                        // this isn't reflected in the TypeScript types. Just in case, and
+                        // to make TypeScript happy, fall back to -1 (which is a
+                        // conventional exit status used for "exited with signal").
+                        status: status ?? -1,
+                    },
+                });
+            }
+            else {
+                this.#completed.resolve({ ok: true, value: undefined });
+            }
+            this.#state = 'stopped';
+        });
+    }
+    /**
+     * Kill this child process. On Linux/macOS, sends a `SIGINT` signal. On
+     * Windows, invokes `taskkill /pid PID /t`.
+     *
+     * Note this function returns immediately. To find out when the process was
+     * actually killed, use the {@link completed} promise.
+     */
+    kill() {
+        switch (this.#state) {
+            case 'started': {
+                this.#actuallyKill();
+                return;
+            }
+            case 'starting': {
+                // We're still starting up, and it's not possible to abort. When we get
+                // the "spawn" event, we'll notice the "killing" state and actually kill
+                // then.
+                this.#state = 'killing';
+                return;
+            }
+            case 'killing':
+            case 'stopped': {
+                // No-op.
+                return;
+            }
+            default: {
+                const never = this.#state;
+                throw new Error(`Internal error: unexpected ScriptChildProcessState: ${String(never)}`);
+            }
+        }
+    }
+    #actuallyKill() {
+        if (this.#child.pid === undefined) {
+            throw new Error(`Internal error: Can't kill child process because it has no pid. ` +
+                `Command: ${JSON.stringify(this.#script.command)}.`);
+        }
+        if (IS_WINDOWS) {
+            // Windows doesn't have signals. Node ChildProcess.kill() sort of emulates
+            // the behavior of SIGKILL (and ignores the signal you pass in), but this
+            // doesn't end child processes. We have child processes because the parent
+            // process is the shell (cmd.exe or PowerShell).
+            // https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/taskkill
+            spawn('taskkill', [
+                '/pid',
+                this.#child.pid.toString(),
+                /* End child processes */ '/t',
+                /* Force. Killing does not seem reliable otherwise. */ '/f',
+            ]);
+        }
+        else {
+            // We used "detached" when we spawned, so our child is the leader of a
+            // process group. Passing the negative of a pid kills all processes in
+            // that group (without the negative, only the leader "sh" process would be
+            // killed).
+            process.kill(-this.#child.pid, 'SIGINT');
+        }
+        this.#state = 'killing';
+    }
+    /**
+     * Generates the PATH environment variable that should be set when this
+     * script's command is spawned.
+     */
+    get #pathEnvironmentVariable() {
+        // Given package "/foo/bar", walk up the path hierarchy to generate
+        // "/foo/bar/node_modules/.bin:/foo/node_modules/.bin:/node_modules/.bin".
+        const entries = [];
+        let cur = this.#script.packageDir;
+        while (true) {
+            entries.push(pathlib.join(cur, 'node_modules', '.bin'));
+            const parent = pathlib.dirname(cur);
+            if (parent === cur) {
+                break;
+            }
+            cur = parent;
+        }
+        // Add the inherited PATH variable, minus any "node_modules/.bin" entries
+        // that were set by the "npm run" command that spawned Wireit.
+        entries.push(PATH_ENV_SUFFIX);
+        // Note the PATH delimiter is platform-dependent.
+        return entries.join(pathlib.delimiter);
+    }
+}
+//# sourceMappingURL=script-child-process.js.map

package/lib/util/ast.js

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as jsonParser from 'jsonc-parser';
+import { parseTree as parseTreeInternal } from 'jsonc-parser';
+import * as pathlib from 'path';
+export function findNamedNodeAtLocation(astNode, path, file) {
+    const node = findNodeAtLocation(astNode, path);
+    const parent = node?.parent;
+    if (node === undefined || parent === undefined) {
+        return { ok: true, value: undefined };
+    }
+    const name = parent.children?.[0];
+    if (parent.type !== 'property' || name === undefined) {
+        return {
+            ok: false,
+            error: {
+                type: 'failure',
+                reason: 'invalid-config-syntax',
+                script: { packageDir: pathlib.dirname(file.path) },
+                diagnostic: {
+                    severity: 'error',
+                    message: `Expected a property, but got a ${parent.type}`,
+                    location: {
+                        file,
+                        range: { offset: astNode.offset, length: astNode.length },
+                    },
+                },
+            },
+        };
+    }
+    node.name = name;
+    return { ok: true, value: node };
+}
+export function findNodeAtLocation(astNode, path) {
+    return jsonParser.findNodeAtLocation(astNode, path);
+}
+export function parseTree(filePath, json) {
+    const errors = [];
+    const result = parseTreeInternal(json, errors);
+    if (errors.length > 0) {
+        const diagnostics = errors.map((error) => ({
+            severity: 'error',
+            message: `JSON syntax error`,
+            location: {
+                file: {
+                    path: filePath,
+                    contents: json,
+                    ast: result,
+                },
+                range: {
+                    offset: error.offset,
+                    length: error.length,
+                },
+            },
+        }));
+        return {
+            ok: false,
+            error: {
+                type: 'failure',
+                reason: 'invalid-json-syntax',
+                script: { packageDir: pathlib.dirname(filePath) },
+                diagnostics,
+            },
+        };
+    }
+    return { ok: true, value: result };
+}
+//# sourceMappingURL=ast.js.map

package/lib/util/async-cache.js

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A cache for values that are asynchronously computed that ensures that we
+ * will compute the value for each key at most once.
+ */
+export class AsyncCache {
+    #cache = new Map();
+    async getOrCompute(key, compute) {
+        let result = this.#cache.get(key);
+        if (result === undefined) {
+            result = compute();
+            this.#cache.set(key, result);
+        }
+        return result;
+    }
+    get values() {
+        return this.#cache.values();
+    }
+}
+//# sourceMappingURL=async-cache.js.map

package/lib/util/copy.js

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from './fs.js';
+import * as pathlib from 'path';
+import { optimizeMkdirs } from './optimize-mkdirs.js';
+import { IS_WINDOWS } from '../util/windows.js';
+/**
+ * Copy all of the given files and directories from one directory to another.
+ *
+ * Directories are NOT copied recursively. If a directory is listed in
+ * {@link entries} without any of its children being listed, then an empty
+ * directory will be created.
+ *
+ * Parent directories are created automatically. E.g. listing "foo/bar" will
+ * automatically create "foo/", even if "foo/" wasn't listed.
+ */
+export const copyEntries = async (entries, sourceDir, destDir) => {
+    if (entries.length === 0) {
+        return;
+    }
+    const files = new Set();
+    const symlinks = new Set();
+    const directories = new Set();
+    for (const { path: absolutePath, dirent } of entries) {
+        const relativePath = pathlib.relative(sourceDir, absolutePath);
+        if (dirent.isDirectory()) {
+            directories.add(pathlib.join(destDir, relativePath));
+        }
+        else {
+            directories.add(pathlib.join(destDir, pathlib.dirname(relativePath)));
+            if (dirent.isSymbolicLink()) {
+                symlinks.add(relativePath);
+            }
+            else {
+                files.add(relativePath);
+            }
+        }
+    }
+    await Promise.all(optimizeMkdirs([...directories]).map((path) => fs.mkdir(path, { recursive: true })));
+    const copyPromises = [];
+    for (const path of files) {
+        copyPromises.push(copyFileGracefully(pathlib.join(sourceDir, path), pathlib.join(destDir, path)));
+    }
+    for (const path of symlinks) {
+        copyPromises.push(copySymlinkGracefully(pathlib.join(sourceDir, path), pathlib.join(destDir, path)));
+    }
+    await Promise.all(copyPromises);
+};
+/**
+ * Copy a file. If the source doesn't exist, do nothing. If the destination
+ * already exists, throw an error.
+ */
+const copyFileGracefully = async (src, dest) => {
+    try {
+        await fs.copyFile(src, dest, 
+        // COPYFILE_FICLONE: Copy the file using copy-on-write semantics, so that
+        //   the copy takes constant time and space. This is a noop currently
+        //   on some platforms, but it's a nice optimization to have.
+        //   See https://github.com/libuv/libuv/issues/2936 for macos support.
+        fs.constants.COPYFILE_EXCL | fs.constants.COPYFILE_FICLONE);
+    }
+    catch (error) {
+        const { code } = error;
+        if (code === /* does not exist */ 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+};
+/**
+ * Copy a symlink verbatim without following or resolving the target. If the
+ * source doesn't exist, do nothing.
+ */
+const copySymlinkGracefully = async (src, dest) => {
+    try {
+        const target = await fs.readlink(src, { encoding: 'buffer' });
+        // Windows symlinks need to be flagged for whether the target is a file or a
+        // directory. We can't derive that from the symlink itself, so we instead
+        // need to check the type of the target.
+        const windowsType = IS_WINDOWS
+            ? // The target could be in the source or the destination, check both.
+                ((await detectWindowsSymlinkType(target, src)) ??
+                    (await detectWindowsSymlinkType(target, dest)) ??
+                    // It doesn't exist in either place, so there's no way to know. Just
+                    // assume "file".
+                    'file')
+            : undefined;
+        await fs.symlink(target, dest, windowsType);
+    }
+    catch (error) {
+        const { code } = error;
+        if (code === /* does not exist */ 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+};
+/**
+ * Resolve symlink {@link target} relative to {@link linkPath} and try to detect
+ * whether the target is a file or directory. If the target doesn't exist,
+ * returns undefined.
+ */
+const detectWindowsSymlinkType = async (target, linkPath) => {
+    const resolved = pathlib.resolve(pathlib.dirname(linkPath), target.toString());
+    try {
+        const stats = await fs.stat(resolved);
+        return stats.isDirectory() ? 'dir' : 'file';
+    }
+    catch (error) {
+        const { code } = error;
+        if (code === /* does not exist */ 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+};
+//# sourceMappingURL=copy.js.map

package/lib/util/deferred.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Convenience class for tracking a promise alongside its resolve and reject
+ * functions.
+ */
+export class Deferred {
+    #resolve;
+    #reject;
+    #settled = false;
+    constructor() {
+        let res, rej;
+        this.promise = new Promise((resolve, reject) => {
+            res = resolve;
+            rej = reject;
+        });
+        this.#resolve = res;
+        this.#reject = rej;
+    }
+    get settled() {
+        return this.#settled;
+    }
+    resolve(value) {
+        this.#settled = true;
+        this.#resolve(value);
+    }
+    reject(reason) {
+        this.#settled = true;
+        this.#reject(reason);
+    }
+}
+//# sourceMappingURL=deferred.js.map

package/lib/util/delete.js

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from './fs.js';
+import * as pathlib from 'path';
+/**
+ * Delete all of the given files and directories.
+ *
+ * Directories are NOT deleted recursively. To delete a directory, it must
+ * either already be empty, or all of its transitive children must be explicitly
+ * provided in the {@link entries} parameter. Deletes are performed depth-first
+ * so that children are deleted before their parents. If a directory is still
+ * not empty after all of the provided children have been deleted, then it is
+ * left in-place.
+ */
+export const deleteEntries = async (entries) => {
+    if (entries.length === 0) {
+        return;
+    }
+    const directories = [];
+    const unlinkPromises = [];
+    for (const { path, dirent } of entries) {
+        if (dirent.isDirectory()) {
+            // Don't delete directories yet.
+            directories.push(path);
+        }
+        else {
+            // Files can start deleting immediately.
+            unlinkPromises.push(unlinkGracefully(path));
+        }
+    }
+    // Wait for all files to be deleted before we start deleting directories,
+    // because directories need to be empty to be deleted.
+    await Promise.all(unlinkPromises);
+    if (directories.length === 0) {
+        return;
+    }
+    if (directories.length === 1) {
+        // Minor optimization for the common case of 1 directory. We've already
+        // deleted all regular files, and we don't delete directories recursively.
+        // So either [1] this directory is empty and we should delete it, or [2] it
+        // has a child directory that was not explicitly listed so we should leave
+        // it in-place.
+        await rmdirGracefully(directories[0]);
+        return;
+    }
+    // We have multiple directories to delete. We must delete child directories
+    // before their parents, because directories need to be empty to be deleted.
+    //
+    // Sorting from longest to shortest path and deleting in serial is a simple
+    // solution, but we prefer to go in parallel.
+    //
+    // Build a tree from the path hierarchy, then delete depth-first.
+    const root = { children: {} };
+    for (const path of directories) {
+        let cur = root;
+        for (const part of path.split(pathlib.sep)) {
+            cur = cur.children[part] ??= { children: {} };
+        }
+        cur.pathIfShouldDelete = path;
+    }
+    await deleteDirectoriesDepthFirst(root);
+};
+/**
+ * Walk a {@link Directory} tree depth-first, deleting any directories that were
+ * scheduled for deletion as long as they are empty.
+ */
+const deleteDirectoriesDepthFirst = async (directory) => {
+    const childrenDeleted = await Promise.all(Object.values(directory.children).map((child) => deleteDirectoriesDepthFirst(child)));
+    if (directory.pathIfShouldDelete === undefined) {
+        // This directory wasn't scheduled for deletion.
+        return false;
+    }
+    if (childrenDeleted.some((deleted) => !deleted)) {
+        // A child directory wasn't deleted, so there's no point trying to delete
+        // this directory, because we know we're not empty and would fail.
+        return false;
+    }
+    return rmdirGracefully(directory.pathIfShouldDelete);
+};
+/**
+ * Delete a file. If it doesn't exist, do nothing.
+ */
+const unlinkGracefully = async (path) => {
+    try {
+        await fs.unlink(path);
+    }
+    catch (error) {
+        const { code } = error;
+        if (code === /* does not exist */ 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+};
+/**
+ * Delete a directory. If it doesn't exist or isn't empty, do nothing.
+ *
+ * @returns True if the directory was deleted or already didn't exist. False
+ * otherwise.
+ */
+const rmdirGracefully = async (path) => {
+    try {
+        await fs.rmdir(path);
+    }
+    catch (error) {
+        const { code } = error;
+        if (code === /* does not exist */ 'ENOENT') {
+            return true;
+        }
+        if (code === /* not empty */ 'ENOTEMPTY') {
+            return false;
+        }
+        throw error;
+    }
+    return true;
+};
+//# sourceMappingURL=delete.js.map

package/lib/util/dispose.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+if (!Symbol.dispose) {
+    Symbol.dispose = Symbol('dispose');
+}
+if (!Symbol.asyncDispose) {
+    Symbol.asyncDispose = Symbol('asyncDispose');
+}
+if (!Symbol.asyncDispose) {
+    Symbol.asyncDispose = Symbol('asyncDispose');
+}
+export {};
+//# sourceMappingURL=dispose.js.map