@rushstack/rush-sdk 5.91.0 → 5.92.0

package/lib/pluginFramework/PluginManager.d.ts

@@ -0,0 +1,47 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { CommandLineConfiguration } from '../api/CommandLineConfiguration';
+import { RushConfiguration } from '../api/RushConfiguration';
+import { IBuiltInPluginConfiguration } from './PluginLoader/BuiltInPluginLoader';
+import { AutoinstallerPluginLoader } from './PluginLoader/AutoinstallerPluginLoader';
+import { RushSession } from './RushSession';
+import { PluginLoaderBase } from './PluginLoader/PluginLoaderBase';
+export interface IPluginManagerOptions {
+    terminal: ITerminal;
+    rushConfiguration: RushConfiguration;
+    rushSession: RushSession;
+    builtInPluginConfigurations: IBuiltInPluginConfiguration[];
+    restrictConsoleOutput: boolean;
+}
+export interface ICustomCommandLineConfigurationInfo {
+    commandLineConfiguration: CommandLineConfiguration;
+    pluginLoader: PluginLoaderBase;
+}
+export declare class PluginManager {
+    private readonly _terminal;
+    private readonly _rushConfiguration;
+    private readonly _rushSession;
+    private readonly _restrictConsoleOutput;
+    private readonly _builtInPluginLoaders;
+    private readonly _autoinstallerPluginLoaders;
+    private readonly _installedAutoinstallerNames;
+    private readonly _loadedPluginNames;
+    private _error;
+    constructor(options: IPluginManagerOptions);
+    /**
+     * If an error occurs while attempting to load plugins, it will be saved in this property.
+     * Rush will attempt to continue and will report the error later by `BaseRushAction._throwPluginErrorIfNeed()`
+     * (unless we are invoking a command that is used to fix plugin problems).
+     */
+    get error(): Error | undefined;
+    updateAsync(): Promise<void>;
+    reinitializeAllPluginsForCommandAsync(commandName: string): Promise<void>;
+    _preparePluginAutoinstallersAsync(pluginLoaders: AutoinstallerPluginLoader[]): Promise<void>;
+    tryInitializeUnassociatedPluginsAsync(): Promise<void>;
+    tryInitializeAssociatedCommandPluginsAsync(commandName: string): Promise<void>;
+    tryGetCustomCommandLineConfigurationInfos(): ICustomCommandLineConfigurationInfo[];
+    private _initializePlugins;
+    private _getUnassociatedPluginLoaders;
+    private _getPluginLoadersForCommand;
+    private _applyPlugin;
+}
+//# sourceMappingURL=PluginManager.d.ts.map

package/lib/pluginFramework/PluginManager.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("pluginFramework/PluginManager");

package/lib/pluginFramework/RushLifeCycle.d.ts

@@ -0,0 +1,66 @@
+import { AsyncParallelHook, AsyncSeriesHook, HookMap } from 'tapable';
+import type { ITelemetryData } from '../logic/Telemetry';
+import type { PhasedCommandHooks } from './PhasedCommandHooks';
+/**
+ * Information about the currently executing command provided to plugins.
+ * @beta
+ */
+export interface IRushCommand {
+    /**
+     * The name of this command, as seen on the command line
+     */
+    readonly actionName: string;
+}
+/**
+ * Information about the currently executing global script command (as defined in command-line.json) provided to plugins.
+ * @beta
+ */
+export interface IGlobalCommand extends IRushCommand {
+}
+/**
+ * Information about the currently executing phased script command (as defined in command-line.json, or default "build" or "rebuild") provided to plugins.
+ * @beta
+ */
+export interface IPhasedCommand extends IRushCommand {
+    /**
+     * Hooks into the execution of the current phased command
+     * @alpha
+     */
+    readonly hooks: PhasedCommandHooks;
+}
+/**
+ * Hooks into the lifecycle of the Rush process invocation that plugins may tap into.
+ *
+ * @beta
+ */
+export declare class RushLifecycleHooks {
+    /**
+     * The hook to run before executing any Rush CLI Command.
+     */
+    initialize: AsyncSeriesHook<IRushCommand>;
+    /**
+     * The hook to run before executing any global Rush CLI Command (defined in command-line.json).
+     */
+    runAnyGlobalCustomCommand: AsyncSeriesHook<IGlobalCommand>;
+    /**
+     * A hook map to allow plugins to hook specific named global commands (defined in command-line.json) before execution.
+     */
+    runGlobalCustomCommand: HookMap<AsyncSeriesHook<IGlobalCommand>>;
+    /**
+     * The hook to run before executing any phased Rush CLI Command (defined in command-line.json, or the default "build" or "rebuild").
+     */
+    runAnyPhasedCommand: AsyncSeriesHook<IPhasedCommand>;
+    /**
+     * A hook map to allow plugins to hook specific named phased commands (defined in command-line.json) before execution.
+     */
+    runPhasedCommand: HookMap<AsyncSeriesHook<IPhasedCommand>>;
+    /**
+     * The hook to run between preparing the common/temp folder and invoking the package manager during "rush install" or "rush update".
+     */
+    beforeInstall: AsyncSeriesHook<IGlobalCommand>;
+    /**
+     * A hook to allow plugins to hook custom logic to process telemetry data.
+     */
+    flushTelemetry: AsyncParallelHook<[ReadonlyArray<ITelemetryData>]>;
+}
+//# sourceMappingURL=RushLifeCycle.d.ts.map

package/lib/pluginFramework/RushLifeCycle.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("pluginFramework/RushLifeCycle");

package/lib/pluginFramework/RushSession.d.ts

@@ -0,0 +1,30 @@
+import { ITerminalProvider } from '@rushstack/node-core-library';
+import { IBuildCacheJson } from '../api/BuildCacheConfiguration';
+import { ICloudBuildCacheProvider } from '../logic/buildCache/ICloudBuildCacheProvider';
+import { ILogger } from './logging/Logger';
+import { RushLifecycleHooks } from './RushLifeCycle';
+/**
+ * @beta
+ */
+export interface IRushSessionOptions {
+    terminalProvider: ITerminalProvider;
+    getIsDebugMode: () => boolean;
+}
+/**
+ * @beta
+ */
+export declare type CloudBuildCacheProviderFactory = (buildCacheJson: IBuildCacheJson) => ICloudBuildCacheProvider;
+/**
+ * @beta
+ */
+export declare class RushSession {
+    private readonly _options;
+    private readonly _cloudBuildCacheProviderFactories;
+    readonly hooks: RushLifecycleHooks;
+    constructor(options: IRushSessionOptions);
+    getLogger(name: string): ILogger;
+    get terminalProvider(): ITerminalProvider;
+    registerCloudBuildCacheProviderFactory(cacheProviderName: string, factory: CloudBuildCacheProviderFactory): void;
+    getCloudBuildCacheProviderFactory(cacheProviderName: string): CloudBuildCacheProviderFactory | undefined;
+}
+//# sourceMappingURL=RushSession.d.ts.map

package/lib/pluginFramework/RushSession.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("pluginFramework/RushSession");

package/lib/pluginFramework/logging/Logger.d.ts

@@ -0,0 +1,40 @@
+import { ITerminalProvider, Terminal } from '@rushstack/node-core-library';
+/**
+ * @beta
+ */
+export interface ILogger {
+    readonly terminal: Terminal;
+    /**
+     * Call this function to emit an error to the Rush runtime.
+     */
+    emitError(error: Error): void;
+    /**
+     * Call this function to emit a warning to the Rush runtime.
+     */
+    emitWarning(warning: Error): void;
+}
+export interface ILoggerOptions {
+    loggerName: string;
+    terminalProvider: ITerminalProvider;
+    getShouldPrintStacks: () => boolean;
+}
+export declare class Logger implements ILogger {
+    private readonly _options;
+    private readonly _errors;
+    private readonly _warnings;
+    readonly terminal: Terminal;
+    constructor(options: ILoggerOptions);
+    get errors(): ReadonlyArray<Error>;
+    get warnings(): ReadonlyArray<Error>;
+    static getErrorMessage(error: Error): string;
+    /**
+     * {@inheritdoc ILogger.emitError}
+     */
+    emitError(error: Error): void;
+    /**
+     * {@inheritdoc ILogger.emitWarning}
+     */
+    emitWarning(warning: Error): void;
+    private get _shouldPrintStacks();
+}
+//# sourceMappingURL=Logger.d.ts.map

package/lib/pluginFramework/logging/Logger.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("pluginFramework/logging/Logger");

package/lib/start-pnpm.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=start-pnpm.d.ts.map

package/lib/start-pnpm.js

@@ -0,0 +1 @@
+module.exports = require("../lib-shim/index")._rushSdk_loadInternalModule("start-pnpm");

package/lib/start.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=start.d.ts.map

package/lib/start.js

@@ -0,0 +1 @@
+module.exports = require("../lib-shim/index")._rushSdk_loadInternalModule("start");

package/lib/startx.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=startx.d.ts.map

package/lib/startx.js

@@ -0,0 +1 @@
+module.exports = require("../lib-shim/index")._rushSdk_loadInternalModule("startx");

package/lib/utilities/AsyncRecycler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * For deleting large folders, AsyncRecycler is significantly faster than Utilities.dangerouslyDeletePath().
+ * It works by moving one or more folders into a temporary "recycler" folder, and then launches a separate
+ * background process to recursively delete that folder.
+ */
+export declare class AsyncRecycler {
+    private _movedFolderCount;
+    private _deleting;
+    private _prefix;
+    /**
+     * The full path of the recycler folder.
+     * Example: `C:\MyRepo\common\rush-recycler`
+     */
+    readonly recyclerFolder: string;
+    constructor(recyclerFolder: string);
+    /**
+     * Synchronously moves the specified folder into the recycler folder.  If the specified folder
+     * does not exist, then no operation is performed.  After calling this function one or more times,
+     * deleteAll() must be called to actually delete the contents of the recycler folder.
+     */
+    moveFolder(folderPath: string): void;
+    /**
+     * This deletes all items under the specified folder, except for the items in the membersToExclude.
+     * To be conservative, a case-insensitive comparison is used for membersToExclude.
+     * The membersToExclude must be file/folder names that would match readdir() results.
+     */
+    moveAllItemsInFolder(folderPath: string, membersToExclude?: ReadonlyArray<string>): void;
+    /**
+     * Starts an asynchronous process to delete the recycler folder.  Deleting will continue
+     * even if the current Node.js process is killed.
+     *
+     * NOTE: To avoid spawning multiple instances of the same command, moveFolder()
+     * MUST NOT be called again after deleteAll() has started.
+     */
+    deleteAll(): void;
+    private _renameOrRecurseInFolder;
+}
+//# sourceMappingURL=AsyncRecycler.d.ts.map

package/lib/utilities/AsyncRecycler.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/AsyncRecycler");

package/lib/utilities/CollatedTerminalProvider.d.ts

@@ -0,0 +1,18 @@
+import { ITerminalProvider, TerminalProviderSeverity } from '@rushstack/node-core-library';
+import { CollatedTerminal } from '@rushstack/stream-collator';
+export interface ICollatedTerminalProviderOptions {
+    debugEnabled: boolean;
+}
+export declare class CollatedTerminalProvider implements ITerminalProvider {
+    private readonly _collatedTerminal;
+    private _hasErrors;
+    private _hasWarnings;
+    private _debugEnabled;
+    readonly supportsColor: boolean;
+    readonly eolCharacter: string;
+    get hasErrors(): boolean;
+    get hasWarnings(): boolean;
+    constructor(collatedTerminal: CollatedTerminal, options?: Partial<ICollatedTerminalProviderOptions>);
+    write(data: string, severity: TerminalProviderSeverity): void;
+}
+//# sourceMappingURL=CollatedTerminalProvider.d.ts.map

package/lib/utilities/CollatedTerminalProvider.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/CollatedTerminalProvider");

package/lib/utilities/Npm.d.ts

@@ -0,0 +1,6 @@
+export declare class Npm {
+    static publishedVersions(packageName: string, cwd: string, env: {
+        [key: string]: string | undefined;
+    }, extraArgs?: string[]): string[];
+}
+//# sourceMappingURL=Npm.d.ts.map

package/lib/utilities/Npm.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/Npm");

package/lib/utilities/OverlappingPathAnalyzer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This is a tool for determining if a set of paths overlap. For example 'lib' and 'lib/x' overlap,
+ * 'lib/x' and 'lib/y' do not.
+ */
+export declare class OverlappingPathAnalyzer<TLabel> {
+    private readonly _root;
+    addPathAndGetFirstEncounteredLabels(path: string, label: TLabel): TLabel[] | undefined;
+}
+//# sourceMappingURL=OverlappingPathAnalyzer.d.ts.map

package/lib/utilities/OverlappingPathAnalyzer.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/OverlappingPathAnalyzer");

package/lib/utilities/PathConstants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The currently-executing rush-lib package's root folder path.
+ */
+export declare const rushLibFolderRootPath: string;
+/**
+ * The path to the assets folder in rush-lib.
+ */
+export declare const assetsFolderPath: string;
+/**
+ * The folder name ("scripts") where the scripts in rush-lib are built.
+ */
+export declare const scriptsFolderName: string;
+export declare const pnpmfileShimFilename: string;
+export declare const installRunScriptFilename: string;
+export declare const installRunRushScriptFilename: string;
+export declare const installRunRushxScriptFilename: string;
+export declare const installRunRushPnpmScriptFilename: string;
+export declare const createLinksScriptFilename: string;
+/**
+ * The path to the scripts folder in rush-lib/dist.
+ */
+export declare const scriptsFolderPath: string;
+//# sourceMappingURL=PathConstants.d.ts.map

package/lib/utilities/PathConstants.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/PathConstants");

package/lib/utilities/Stopwatch.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Used with the Stopwatch class.
+ */
+export declare enum StopwatchState {
+    Stopped = 1,
+    Started = 2
+}
+/**
+ * Represents a readonly view of a `Stopwatch`.
+ * @beta
+ */
+export interface IStopwatchResult {
+    /**
+     * Displays how long the stopwatch has been executing in a human readable format.
+     */
+    toString(): string;
+    /**
+     * Get the duration in seconds.
+     */
+    get duration(): number;
+    /**
+     * Return the start time of the most recent stopwatch run.
+     */
+    get startTime(): number | undefined;
+    /**
+     * Return the end time of the most recent stopwatch run.
+     */
+    get endTime(): number | undefined;
+}
+/**
+ * Represents a typical timer/stopwatch which keeps track
+ * of elapsed time in between two events.
+ */
+export declare class Stopwatch implements IStopwatchResult {
+    private _startTime;
+    private _endTime;
+    private _state;
+    private _getTime;
+    constructor(getTime?: () => number);
+    /**
+     * Static helper function which creates a stopwatch which is immediately started
+     */
+    static start(): Stopwatch;
+    get state(): StopwatchState;
+    /**
+     * Starts the stopwatch. Note that if end() has been called,
+     * reset() should be called before calling start() again.
+     */
+    start(): Stopwatch;
+    /**
+     * Stops executing the stopwatch and saves the current timestamp
+     */
+    stop(): Stopwatch;
+    /**
+     * Resets all values of the stopwatch back to the original
+     */
+    reset(): Stopwatch;
+    /**
+     * Displays how long the stopwatch has been executing in a human readable format.
+     */
+    toString(): string;
+    /**
+     * Get the duration in seconds.
+     */
+    get duration(): number;
+    /**
+     * Return the start time of the most recent stopwatch run.
+     */
+    get startTime(): number | undefined;
+    /**
+     * Return the end time of the most recent stopwatch run.
+     */
+    get endTime(): number | undefined;
+}
+//# sourceMappingURL=Stopwatch.d.ts.map

package/lib/utilities/Stopwatch.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/Stopwatch");

package/lib/utilities/TarExecutable.d.ts

@@ -0,0 +1,32 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { RushConfigurationProject } from '../api/RushConfigurationProject';
+export interface ITarOptionsBase {
+    logFilePath: string;
+}
+export interface IUntarOptions extends ITarOptionsBase {
+    archivePath: string;
+    outputFolderPath: string;
+}
+export interface ICreateArchiveOptions extends ITarOptionsBase {
+    archivePath: string;
+    paths: string[];
+    project: RushConfigurationProject;
+}
+export declare class TarExecutable {
+    private _tarExecutablePath;
+    private constructor();
+    static tryInitializeAsync(terminal: ITerminal): Promise<TarExecutable | undefined>;
+    /**
+     * @returns
+     * The "tar" exit code
+     */
+    tryUntarAsync(options: IUntarOptions): Promise<number>;
+    /**
+     * @returns
+     * The "tar" exit code
+     */
+    tryCreateArchiveFromProjectPathsAsync(options: ICreateArchiveOptions): Promise<number>;
+    private _spawnTarWithLoggingAsync;
+    private static _tryFindTarExecutablePathAsync;
+}
+//# sourceMappingURL=TarExecutable.d.ts.map

package/lib/utilities/TarExecutable.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/TarExecutable");

package/lib/utilities/Utilities.d.ts

@@ -0,0 +1,189 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as child_process from 'child_process';
+import type * as stream from 'stream';
+import { RushConfiguration } from '../api/RushConfiguration';
+import { syncNpmrc } from './npmrcUtilities';
+export declare type UNINITIALIZED = 'UNINITIALIZED';
+export declare const UNINITIALIZED: UNINITIALIZED;
+export interface IEnvironment {
+    [environmentVariableName: string]: string | undefined;
+}
+/**
+ * Options for Utilities.executeCommand().
+ */
+export interface IExecuteCommandOptions {
+    command: string;
+    args: string[];
+    workingDirectory: string;
+    environment?: IEnvironment;
+    suppressOutput?: boolean;
+    keepEnvironment?: boolean;
+}
+/**
+ * Options for Utilities.installPackageInDirectory().
+ */
+export interface IInstallPackageInDirectoryOptions {
+    directory: string;
+    packageName: string;
+    version: string;
+    tempPackageTitle: string;
+    maxInstallAttempts: number;
+    commonRushConfigFolder: string | undefined;
+    suppressOutput?: boolean;
+}
+export interface ILifecycleCommandOptions {
+    /**
+     * The rush configuration, if the command is running in a rush repo.
+     */
+    rushConfiguration: RushConfiguration | undefined;
+    /**
+     * Working directory for running the command
+     */
+    workingDirectory: string;
+    /**
+     * The folder containing a local .npmrc, which will be used for the INIT_CWD environment variable
+     */
+    initCwd: string;
+    /**
+     * If true, suppress the process's output, but if there is a nonzero exit code then print stderr
+     */
+    handleOutput: boolean;
+    /**
+     * Options for what should be added to the PATH variable
+     */
+    environmentPathOptions: IEnvironmentPathOptions;
+}
+export interface IEnvironmentPathOptions {
+    /**
+     * If true, include <project root>/node_modules/.bin in the PATH. If both this and
+     * {@link IEnvironmentPathOptions.includeRepoBin} are set, this path will take precedence.
+     */
+    includeProjectBin?: boolean;
+    /**
+     * If true, include <repo root>/common/temp/node_modules/.bin in the PATH.
+     */
+    includeRepoBin?: boolean;
+    /**
+     * Additional folders to be prepended to the search PATH.
+     */
+    additionalPathFolders?: string[] | undefined;
+}
+export interface IDisposable {
+    dispose(): void;
+}
+export declare class Utilities {
+    static syncNpmrc: typeof syncNpmrc;
+    /**
+     * Get the user's home directory. On windows this looks something like "C:\users\username\" and on UNIX
+     * this looks something like "/home/username/"
+     */
+    static getHomeFolder(): string;
+    /**
+     * Node.js equivalent of performance.now().
+     */
+    static getTimeInMs(): number;
+    /**
+     * Returns the values from a Set<T>
+     */
+    static getSetAsArray<T>(set: Set<T> | ReadonlySet<T>): T[];
+    /**
+     * Retries a function until a timeout is reached. The function is expected to throw if it failed and
+     *  should be retried.
+     */
+    static retryUntilTimeout<TResult>(fn: () => TResult, maxWaitTimeMs: number, getTimeoutError: (innerError: Error) => Error, fnName: string): TResult;
+    /**
+     * Creates the specified folder by calling FileSystem.ensureFolder(), but using a
+     * retry loop to recover from temporary locks that may be held by other processes.
+     * If the folder already exists, no error occurs.
+     */
+    static createFolderWithRetry(folderName: string): void;
+    /**
+     * Determines if the path points to a file and that it exists.
+     */
+    static fileExists(filePath: string): boolean;
+    /**
+     * Determines if a path points to a directory and that it exists.
+     */
+    static directoryExists(directoryPath: string): boolean;
+    /**
+     * BE VERY CAREFUL CALLING THIS FUNCTION!
+     * If you specify the wrong folderPath (e.g. "/"), it could potentially delete your entire
+     * hard disk.
+     */
+    static dangerouslyDeletePath(folderPath: string): void;
+    /**
+     * Attempts to delete a file. If it does not exist, or the path is not a file, it no-ops.
+     */
+    static deleteFile(filePath: string): void;
+    static isFileTimestampCurrent(dateToCompare: Date, inputFilenames: string[]): boolean;
+    /**
+     * Executes the command with the specified command-line parameters, and waits for it to complete.
+     * The current directory will be set to the specified workingDirectory.
+     */
+    static executeCommand(options: IExecuteCommandOptions): void;
+    /**
+     * Executes the command with the specified command-line parameters, and waits for it to complete.
+     * The current directory will be set to the specified workingDirectory.
+     */
+    static executeCommandAndCaptureOutput(command: string, args: string[], workingDirectory: string, environment?: IEnvironment, keepEnvironment?: boolean): string;
+    /**
+     * Attempts to run Utilities.executeCommand() up to maxAttempts times before giving up.
+     */
+    static executeCommandWithRetry(options: IExecuteCommandOptions, maxAttempts: number, retryCallback?: () => void): void;
+    /**
+     * Executes the command using cmd if running on windows, or using sh if running on a non-windows OS.
+     * @param command - the command to run on shell
+     * @param options - options for how the command should be run
+     */
+    static executeLifecycleCommand(command: string, options: ILifecycleCommandOptions): number;
+    /**
+     * Executes the command using cmd if running on windows, or using sh if running on a non-windows OS.
+     * @param command - the command to run on shell
+     * @param options - options for how the command should be run
+     */
+    static executeLifecycleCommandAsync(command: string, options: ILifecycleCommandOptions): child_process.ChildProcess;
+    /**
+     * For strings passed to a shell command, this adds appropriate escaping
+     * to avoid misinterpretation of spaces or special characters.
+     *
+     * Example: 'hello there' --> '"hello there"'
+     */
+    static escapeShellParameter(parameter: string): string;
+    /**
+     * Installs a package by name and version in the specified directory.
+     */
+    static installPackageInDirectory(options: IInstallPackageInDirectoryOptions): void;
+    /**
+     * Copies the file "sourcePath" to "destinationPath", overwriting the target file location.
+     * If the source file does not exist, then the target file is deleted.
+     */
+    static syncFile(sourcePath: string, destinationPath: string): void;
+    static getRushConfigNotFoundError(): Error;
+    static usingAsync<TDisposable extends IDisposable>(getDisposableAsync: () => Promise<TDisposable> | IDisposable, doActionAsync: (disposable: TDisposable) => Promise<void> | void): Promise<void>;
+    static readStreamToBufferAsync(stream: stream.Readable): Promise<Buffer>;
+    private static _executeLifecycleCommandInternal;
+    /**
+     * Returns a process.env environment suitable for executing lifecycle scripts.
+     * @param initialEnvironment - an existing environment to copy instead of process.env
+     *
+     * @remarks
+     * Rush._assignRushInvokedFolder() assigns the `RUSH_INVOKED_FOLDER` variable globally
+     * via the parent process's environment.
+     */
+    private static _createEnvironmentForRushCommand;
+    /**
+     * Prepend the node_modules/.bin folder under the specified folder to the specified PATH variable. For example,
+     * if `rootDirectory` is "/foobar" and `existingPath` is "/bin", this function will return
+     * "/foobar/node_modules/.bin:/bin"
+     */
+    private static _prependNodeModulesBinToPath;
+    /**
+     * Executes the command with the specified command-line parameters, and waits for it to complete.
+     * The current directory will be set to the specified workingDirectory.
+     */
+    private static _executeCommandInternal;
+    private static _processResult;
+}
+//# sourceMappingURL=Utilities.d.ts.map

package/lib/utilities/Utilities.js

@@ -0,0 +1 @@
+module.exports = require("../../lib-shim/index")._rushSdk_loadInternalModule("utilities/Utilities");