@rushstack/rush-sdk 5.143.0-pr5009.0 → 5.143.0-pr5009.1

package/lib/logic/ApprovedPackagesChecker.d.ts

@@ -0,0 +1,23 @@
+import type { RushConfiguration } from '../api/RushConfiguration';
+export declare class ApprovedPackagesChecker {
+    private readonly _rushConfiguration;
+    private _approvedPackagesPolicy;
+    private _filesAreOutOfDate;
+    constructor(rushConfiguration: RushConfiguration);
+    /**
+     * If true, the files on disk are out of date.
+     */
+    get approvedPackagesFilesAreOutOfDate(): boolean;
+    /**
+     * Examines the current dependencies for the projects specified in RushConfiguration,
+     * and then adds them to the 'browser-approved-packages.json' and
+     * 'nonbrowser-approved-packages.json' config files.  If these files don't exist,
+     * they will be created.
+     *
+     * If the "approvedPackagesPolicy" feature is not enabled, then no action is taken.
+     */
+    rewriteConfigFiles(): void;
+    private _updateApprovedPackagesPolicy;
+    private _collectDependencies;
+}
+//# sourceMappingURL=ApprovedPackagesChecker.d.ts.map

package/lib/logic/ApprovedPackagesChecker.js

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

package/lib/logic/InstallManagerFactory.d.ts

@@ -0,0 +1,9 @@
+import type { PurgeManager } from './PurgeManager';
+import type { RushConfiguration } from '../api/RushConfiguration';
+import type { RushGlobalFolder } from '../api/RushGlobalFolder';
+import type { BaseInstallManager } from './base/BaseInstallManager';
+import type { IInstallManagerOptions } from './base/BaseInstallManagerTypes';
+export declare class InstallManagerFactory {
+    static getInstallManagerAsync(rushConfiguration: RushConfiguration, rushGlobalFolder: RushGlobalFolder, purgeManager: PurgeManager, options: IInstallManagerOptions): Promise<BaseInstallManager>;
+}
+//# sourceMappingURL=InstallManagerFactory.d.ts.map

package/lib/logic/InstallManagerFactory.js

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

package/lib/logic/InteractiveUpgrader.d.ts

@@ -0,0 +1,17 @@
+import type { RushConfiguration } from '../api/RushConfiguration';
+import { type IDepsToUpgradeAnswers } from '../utilities/InteractiveUpgradeUI';
+import type { RushConfigurationProject } from '../api/RushConfigurationProject';
+interface IUpgradeInteractiveDeps {
+    projects: RushConfigurationProject[];
+    depsToUpgrade: IDepsToUpgradeAnswers;
+}
+export declare class InteractiveUpgrader {
+    private readonly _rushConfiguration;
+    constructor(rushConfiguration: RushConfiguration);
+    upgradeAsync(): Promise<IUpgradeInteractiveDeps>;
+    private _getUserSelectedDependenciesToUpgradeAsync;
+    private _getUserSelectedProjectForUpgradeAsync;
+    private _getPackageDependenciesStatusAsync;
+}
+export {};
+//# sourceMappingURL=InteractiveUpgrader.d.ts.map

package/lib/logic/InteractiveUpgrader.js

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

package/lib/logic/LinkManagerFactory.d.ts

@@ -0,0 +1,6 @@
+import type { RushConfiguration } from '../api/RushConfiguration';
+import type { BaseLinkManager } from './base/BaseLinkManager';
+export declare class LinkManagerFactory {
+    static getLinkManager(rushConfiguration: RushConfiguration): BaseLinkManager;
+}
+//# sourceMappingURL=LinkManagerFactory.d.ts.map

package/lib/logic/LinkManagerFactory.js

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

package/lib/logic/PackageJsonUpdater.d.ts

@@ -0,0 +1,131 @@
+/// <reference path="../../src/npm-check-typings.d.ts" />
+import type * as NpmCheck from 'npm-check';
+import type { RushConfiguration } from '../api/RushConfiguration';
+import { DependencyType } from '../api/PackageJsonEditor';
+import type { RushGlobalFolder } from '../api/RushGlobalFolder';
+import type { RushConfigurationProject } from '../api/RushConfigurationProject';
+import type { VersionMismatchFinderEntity } from './versionMismatch/VersionMismatchFinderEntity';
+import { type IPackageJsonUpdaterRushBaseUpdateOptions } from './PackageJsonUpdaterTypes';
+/**
+ * Options for adding a dependency to a particular project.
+ */
+export interface IPackageJsonUpdaterRushUpgradeOptions {
+    /**
+     * The projects whose package.jsons should get updated
+     */
+    projects: RushConfigurationProject[];
+    /**
+     * The dependencies to be added.
+     */
+    packagesToAdd: NpmCheck.INpmCheckPackage[];
+    /**
+     * If specified, other packages that use this dependency will also have their package.json's updated.
+     */
+    updateOtherPackages: boolean;
+    /**
+     * If specified, "rush update" will not be run after updating the package.json file(s).
+     */
+    skipUpdate: boolean;
+    /**
+     * If specified, "rush update" will be run in debug mode.
+     */
+    debugInstall: boolean;
+    /**
+     * The variant to consider when performing installations and validating shrinkwrap updates.
+     */
+    variant: string | undefined;
+}
+/**
+ * Configuration options for adding or updating a dependency in single project
+ * or removing a dependency from a particular project
+ */
+export interface IBaseUpdateProjectOptions {
+    /**
+     * The project which will have its package.json updated
+     */
+    project: VersionMismatchFinderEntity;
+    /**
+     * Map of packages to update
+     * Its key is the name of the dependency to be added or updated in the project
+     * Its value is the new SemVer specifier that should be added to the project's package.json
+     * If trying to remove this packages, value can be empty string
+     */
+    dependenciesToAddOrUpdateOrRemove: Record<string, string>;
+}
+/**
+ * Configuration options for adding or updating a dependency in a single project
+ */
+export interface IUpdateProjectOptions extends IBaseUpdateProjectOptions {
+    /**
+     * The type of dependency that should be updated. If left empty, this will be auto-detected.
+     * If it cannot be auto-detected an exception will be thrown.
+     */
+    dependencyType?: DependencyType;
+}
+/**
+ * Configuration options for removing dependencies from a single project
+ */
+export interface IRemoveProjectOptions extends IBaseUpdateProjectOptions {
+}
+/**
+ * A helper class for managing the dependencies of various package.json files.
+ * @internal
+ */
+export declare class PackageJsonUpdater {
+    private _rushConfiguration;
+    private _rushGlobalFolder;
+    private readonly _terminalProvider;
+    private readonly _terminal;
+    constructor(rushConfiguration: RushConfiguration, rushGlobalFolder: RushGlobalFolder);
+    /**
+     * Upgrade dependencies to a particular project, or across specified projects. This is the core business logic for
+     * "rush upgrade-interactive".
+     */
+    doRushUpgradeAsync(options: IPackageJsonUpdaterRushUpgradeOptions): Promise<void>;
+    doRushUpdateAsync(options: IPackageJsonUpdaterRushBaseUpdateOptions): Promise<void>;
+    private _doUpdateAsync;
+    /**
+     * Adds a dependency to a particular project. The core business logic for "rush add".
+     */
+    private _doRushAddAsync;
+    private _updateProjectsAsync;
+    private _getUpdates;
+    /**
+     * Remove a dependency from a particular project. The core business logic for "rush remove".
+     */
+    private _doRushRemoveAsync;
+    /**
+     * Updates several projects' package.json files
+     */
+    updateProjects(projectUpdates: IUpdateProjectOptions[]): void;
+    /**
+     * Updates a single project's package.json file
+     */
+    updateProject(options: IUpdateProjectOptions): void;
+    removePackageFromProject(options: IRemoveProjectOptions): void;
+    /**
+     * Selects an appropriate version number for a particular package, given an optional initial SemVer spec.
+     * If ensureConsistentVersions, tries to pick a version that will be consistent.
+     * Otherwise, will choose the latest semver matching the initialSpec and append the proper range style.
+     * @param projects - the projects which will have their package.json's updated
+     * @param packageName - the name of the package to be used
+     * @param initialSpec - a semver pattern that should be used to find the latest version matching the spec
+     * @param implicitlyPreferredVersion - the implicitly preferred (aka common/primary) version of the package in use
+     * @param rangeStyle - if this version is selected by querying registry, then this range specifier is prepended to
+     *   the selected version.
+     */
+    private _getNormalizedVersionSpecAsync;
+    private _collectAllDownstreamDependencies;
+    /**
+     * Given a package name, this function returns a {@see RushConfigurationProject} if the package is a project
+     * in the local Rush repo and is not marked as cyclic for any of the projects.
+     *
+     * @remarks
+     * This function throws an error if adding the discovered local project as a dependency
+     * would create a dependency cycle, or if it would be added to multiple projects.
+     */
+    private _tryGetLocalProject;
+    private _cheaplyDetectSemVerRangeStyle;
+    private _normalizeDepsToUpgrade;
+}
+//# sourceMappingURL=PackageJsonUpdater.d.ts.map

package/lib/logic/PackageJsonUpdater.js

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

package/lib/logic/PackageLookup.d.ts

@@ -0,0 +1,8 @@
+import type { BasePackage } from './base/BasePackage';
+export declare class PackageLookup {
+    private _packageMap;
+    constructor();
+    loadTree(root: BasePackage): void;
+    getPackage(nameAndVersion: string): BasePackage | undefined;
+}
+//# sourceMappingURL=PackageLookup.d.ts.map

package/lib/logic/PackageLookup.js

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

package/lib/logic/ProjectImpactGraphGenerator.d.ts

@@ -0,0 +1,51 @@
+import type { RushConfiguration } from '../api/RushConfiguration';
+import { type ITerminal } from '@rushstack/terminal';
+/**
+ * Project property configuration
+ */
+export interface IProjectImpactGraphProjectConfiguration {
+    includedGlobs: string[];
+    excludedGlobs?: string[];
+    dependentProjects: string[];
+}
+/**
+ * The schema of `project-impact-graph.yaml`
+ */
+export interface IProjectImpactGraphFile {
+    globalExcludedGlobs: string[];
+    projects: Record<string, IProjectImpactGraphProjectConfiguration>;
+}
+export declare class ProjectImpactGraphGenerator {
+    private readonly _terminal;
+    /**
+     * The Rush configuration
+     */
+    private readonly _rushConfiguration;
+    /**
+     * Full path of repository root
+     */
+    private readonly _repositoryRoot;
+    /**
+     * Full path to `project-impact-graph.yaml`
+     */
+    private readonly _projectImpactGraphFilePath;
+    /**
+     * Get repositoryRoot and load projects within the rush.json
+     */
+    constructor(terminal: ITerminal, rushConfiguration: RushConfiguration);
+    /**
+     * Load global excluded globs
+     */
+    private _loadGlobalExcludedGlobsAsync;
+    /**
+     * Load project excluded globs
+     * @param projectRootRelativePath - project root relative path
+     */
+    private _tryLoadProjectExcludedGlobsAsync;
+    /**
+     * Core Logic: generate project-impact-graph.yaml
+     */
+    generateAsync(): Promise<void>;
+    validateAsync(): Promise<boolean>;
+}
+//# sourceMappingURL=ProjectImpactGraphGenerator.d.ts.map

package/lib/logic/ProjectImpactGraphGenerator.js

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

package/lib/logic/ProjectWatcher.d.ts

@@ -0,0 +1,78 @@
+import { type ITerminal } from '@rushstack/terminal';
+import type { IInputsSnapshot, GetInputsSnapshotAsyncFn } from './incremental/InputsSnapshot';
+import type { RushConfiguration } from '../api/RushConfiguration';
+import type { RushConfigurationProject } from '../api/RushConfigurationProject';
+export interface IProjectWatcherOptions {
+    getInputsSnapshotAsync: GetInputsSnapshotAsyncFn;
+    debounceMs?: number;
+    rushConfiguration: RushConfiguration;
+    projectsToWatch: ReadonlySet<RushConfigurationProject>;
+    terminal: ITerminal;
+    initialSnapshot?: IInputsSnapshot | undefined;
+}
+export interface IProjectChangeResult {
+    /**
+     * The set of projects that have changed since the last iteration
+     */
+    changedProjects: ReadonlySet<RushConfigurationProject>;
+    /**
+     * Contains the git hashes for all tracked files in the repo
+     */
+    inputsSnapshot: IInputsSnapshot;
+}
+export interface IPromptGeneratorFunction {
+    (isPaused: boolean): Iterable<string>;
+}
+/**
+ * This class is for incrementally watching a set of projects in the repository for changes.
+ *
+ * We are manually using fs.watch() instead of `chokidar` because all we want from the file system watcher is a boolean
+ * signal indicating that "at least 1 file in a watched project changed". We then defer to getInputsSnapshotAsync (which
+ * is responsible for change detection in all incremental builds) to determine what actually chanaged.
+ *
+ * Calling `waitForChange()` will return a promise that resolves when the package-deps of one or
+ * more projects differ from the value the previous time it was invoked. The first time will always resolve with the full selection.
+ */
+export declare class ProjectWatcher {
+    private readonly _getInputsSnapshotAsync;
+    private readonly _debounceMs;
+    private readonly _repoRoot;
+    private readonly _rushConfiguration;
+    private readonly _projectsToWatch;
+    private readonly _terminal;
+    private _initialSnapshot;
+    private _previousSnapshot;
+    private _forceChangedProjects;
+    private _resolveIfChanged;
+    private _getPromptLines;
+    private _renderedStatusLines;
+    isPaused: boolean;
+    constructor(options: IProjectWatcherOptions);
+    pause(): void;
+    resume(): void;
+    invalidateProject(project: RushConfigurationProject, reason: string): boolean;
+    invalidateAll(reason: string): void;
+    clearStatus(): void;
+    setPromptGenerator(promptGenerator: IPromptGeneratorFunction): void;
+    /**
+     * Waits for a change to the package-deps of one or more of the selected projects, since the previous invocation.
+     * Will return immediately the first time it is invoked, since no state has been recorded.
+     * If no change is currently present, watches the source tree of all selected projects for file changes.
+     * `waitForChange` is not allowed to be called multiple times concurrently.
+     */
+    waitForChangeAsync(onWatchingFiles?: () => void): Promise<IProjectChangeResult>;
+    private _setStatus;
+    /**
+     * Determines which, if any, projects (within the selection) have new hashes for files that are not in .gitignore
+     */
+    private _computeChangedAsync;
+    private _commitChanges;
+    /**
+     * Tests for inequality of the passed Maps. Order invariant.
+     *
+     * @returns `true` if the maps are different, `false` otherwise
+     */
+    private static _haveProjectDepsChanged;
+    private static _enumeratePathsToWatch;
+}
+//# sourceMappingURL=ProjectWatcher.d.ts.map

package/lib/logic/ProjectWatcher.js

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

package/lib/logic/TempProjectHelper.d.ts

@@ -0,0 +1,19 @@
+import type { RushConfigurationProject } from '../api/RushConfigurationProject';
+import type { RushConfiguration } from '../api/RushConfiguration';
+import type { Subspace } from '../api/Subspace';
+export declare class TempProjectHelper {
+    private _rushConfiguration;
+    private _subspace;
+    constructor(rushConfiguration: RushConfiguration, subspace: Subspace);
+    /**
+     * Deletes the existing tarball and creates a tarball for the given rush project
+     */
+    createTempProjectTarball(rushProject: RushConfigurationProject): void;
+    /**
+     * Gets the path to the tarball
+     * Example: "C:\MyRepo\common\temp\projects\my-project-2.tgz"
+     */
+    getTarballFilePath(project: RushConfigurationProject): string;
+    getTempProjectFolder(rushProject: RushConfigurationProject): string;
+}
+//# sourceMappingURL=TempProjectHelper.d.ts.map

package/lib/logic/TempProjectHelper.js

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

package/lib/logic/VersionManager.d.ts

@@ -0,0 +1,48 @@
+import { type IPackageJson } from '@rushstack/node-core-library';
+import { type BumpType } from '../api/VersionPolicy';
+import { ChangeFile } from '../api/ChangeFile';
+import { RushConfiguration } from '../api/RushConfiguration';
+import type { VersionPolicyConfiguration } from '../api/VersionPolicyConfiguration';
+export declare class VersionManager {
+    private _rushConfiguration;
+    private _userEmail;
+    private _versionPolicyConfiguration;
+    readonly updatedProjects: Map<string, IPackageJson>;
+    readonly changeFiles: Map<string, ChangeFile>;
+    constructor(rushConfiguration: RushConfiguration, userEmail: string, versionPolicyConfiguration: VersionPolicyConfiguration);
+    /**
+     * Ensures project versions follow the provided version policy. If version policy is not
+     * provided, all projects will have their version checked according to the associated version policy.
+     * package.json files will be updated if needed.
+     * This method does not commit changes.
+     * @param versionPolicyName -- version policy name
+     * @param shouldCommit -- should update files to disk
+     * @param force -- update even when project version is higher than policy version.
+     */
+    ensure(versionPolicyName?: string, shouldCommit?: boolean, force?: boolean): void;
+    /**
+     * Bumps versions following version policies.
+     *
+     * @param lockStepVersionPolicyName - a specified lock step version policy name. Without this value,
+     * versions for all lock step policies and all individual policies will be bumped.
+     * With this value, only the specified lock step policy will be bumped along with all individual policies.
+     * @param bumpType - overrides the default bump type and only works for lock step policy
+     * @param identifier - overrides the prerelease identifier and only works for lock step policy
+     * @param shouldCommit - whether the changes will be written to disk
+     */
+    bumpAsync(lockStepVersionPolicyName?: string, bumpType?: BumpType, identifier?: string, shouldCommit?: boolean): Promise<void>;
+    private _ensure;
+    private _getManuallyVersionedProjects;
+    private _updateVersionsByPolicy;
+    private _isPrerelease;
+    private _addChangeInfo;
+    private _updateDependencies;
+    private _updateProjectAllDependencies;
+    private _updateProjectDependencies;
+    private _shouldTrackDependencyChange;
+    private _trackDependencyChange;
+    private _addChange;
+    private _updatePackageJsonFiles;
+    private _createChangeInfo;
+}
+//# sourceMappingURL=VersionManager.d.ts.map

package/lib/logic/VersionManager.js

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

package/lib/logic/base/BaseInstallManager.d.ts

@@ -0,0 +1,57 @@
+import { type ITerminal } from '@rushstack/terminal';
+import type { AsyncRecycler } from '../../utilities/AsyncRecycler';
+import type { BaseShrinkwrapFile } from './BaseShrinkwrapFile';
+import { type LastInstallFlag } from '../../api/LastInstallFlag';
+import type { PurgeManager } from '../PurgeManager';
+import type { RushConfiguration } from '../../api/RushConfiguration';
+import type { RushGlobalFolder } from '../../api/RushGlobalFolder';
+import type { IInstallManagerOptions } from './BaseInstallManagerTypes';
+import type { Subspace } from '../../api/Subspace';
+import { ProjectImpactGraphGenerator } from '../ProjectImpactGraphGenerator';
+/**
+ * Pnpm don't support --ignore-compatibility-db, so use --config.ignoreCompatibilityDb for now.
+ */
+export declare const pnpmIgnoreCompatibilityDbParameter: string;
+/**
+ * This class implements common logic between "rush install" and "rush update".
+ */
+export declare abstract class BaseInstallManager {
+    private readonly _commonTempLinkFlag;
+    private _npmSetupValidated;
+    private _syncNpmrcAlreadyCalled;
+    protected readonly _terminal: ITerminal;
+    protected readonly rushConfiguration: RushConfiguration;
+    protected readonly rushGlobalFolder: RushGlobalFolder;
+    protected readonly installRecycler: AsyncRecycler;
+    protected readonly options: IInstallManagerOptions;
+    protected readonly subspaceInstallFlags: Map<string, LastInstallFlag>;
+    constructor(rushConfiguration: RushConfiguration, rushGlobalFolder: RushGlobalFolder, purgeManager: PurgeManager, options: IInstallManagerOptions);
+    doInstallAsync(): Promise<void>;
+    protected abstract prepareCommonTempAsync(subspace: Subspace, shrinkwrapFile: BaseShrinkwrapFile | undefined): Promise<{
+        shrinkwrapIsUpToDate: boolean;
+        shrinkwrapWarnings: string[];
+    }>;
+    protected abstract installAsync(cleanInstall: boolean, subspace: Subspace): Promise<void>;
+    protected abstract postInstallAsync(subspace: Subspace): Promise<void>;
+    protected canSkipInstallAsync(lastModifiedDate: Date, subspace: Subspace, variant: string | undefined): Promise<boolean>;
+    protected prepareAsync(subspace: Subspace, variant: string | undefined, projectImpactGraphGenerator: ProjectImpactGraphGenerator | undefined): Promise<{
+        shrinkwrapIsUpToDate: boolean;
+        npmrcHash: string | undefined;
+        projectImpactGraphIsUpToDate: boolean;
+        variantIsUpToDate: boolean;
+    }>;
+    /**
+     * Git hooks are only installed if the repo opts in by including files in /common/git-hooks
+     */
+    private _installGitHooksAsync;
+    /**
+     * Used when invoking the NPM tool.  Appends the common configuration options
+     * to the command-line.
+     */
+    protected pushConfigurationArgs(args: string[], options: IInstallManagerOptions, subspace: Subspace): void;
+    private _checkIfReleaseIsPublishedAsync;
+    private _queryIfReleaseIsPublishedAsync;
+    private _syncTempShrinkwrap;
+    protected validateNpmSetupAsync(): Promise<void>;
+}
+//# sourceMappingURL=BaseInstallManager.d.ts.map

package/lib/logic/base/BaseInstallManager.js

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

package/lib/logic/base/BaseLinkManager.d.ts

@@ -0,0 +1,35 @@
+import { type IFileSystemCreateLinkOptions } from '@rushstack/node-core-library';
+import type { RushConfiguration } from '../../api/RushConfiguration';
+import type { BasePackage } from './BasePackage';
+export declare enum SymlinkKind {
+    File = 0,
+    Directory = 1
+}
+export interface IBaseLinkManagerCreateSymlinkOptions extends IFileSystemCreateLinkOptions {
+    symlinkKind: SymlinkKind;
+}
+export declare abstract class BaseLinkManager {
+    protected _rushConfiguration: RushConfiguration;
+    constructor(rushConfiguration: RushConfiguration);
+    static _createSymlink(options: IBaseLinkManagerCreateSymlinkOptions): void;
+    /**
+     * For a Package object that represents a top-level Rush project folder
+     * (i.e. with source code that we will be building), this clears out its
+     * node_modules folder and then recursively creates all the symlinked folders.
+     */
+    protected static _createSymlinksForTopLevelProject(localPackage: BasePackage): void;
+    /**
+     * This is a helper function used by createSymlinksForTopLevelProject().
+     * It will recursively creates symlinked folders corresponding to each of the
+     * Package objects in the provided tree.
+     */
+    private static _createSymlinksForDependencies;
+    /**
+     * Creates node_modules symlinks for all Rush projects defined in the RushConfiguration.
+     * @param force - Normally the operation will be skipped if the links are already up to date;
+     *   if true, this option forces the links to be recreated.
+     */
+    createSymlinksForProjectsAsync(force: boolean): Promise<void>;
+    protected abstract _linkProjectsAsync(): Promise<void>;
+}
+//# sourceMappingURL=BaseLinkManager.d.ts.map

package/lib/logic/base/BaseLinkManager.js

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

package/lib/logic/base/BasePackage.d.ts

@@ -0,0 +1,113 @@
+import { type IPackageJson } from '@rushstack/node-core-library';
+/**
+ * The type of dependency; used by IPackageDependency.
+ */
+export declare enum PackageDependencyKind {
+    Normal = 0,
+    /**
+     * The dependency was listed in the optionalDependencies section of package.json.
+     */
+    Optional = 1,
+    /**
+     * The dependency should be a symlink to a project that is locally built by Rush..
+     */
+    LocalLink = 2
+}
+export interface IPackageDependency {
+    /**
+     * The name of the dependency
+     */
+    name: string;
+    /**
+     * The requested version, which may be a pattern such as "^1.2.3"
+     */
+    versionRange: string;
+    /**
+     * The kind of dependency
+     */
+    kind: PackageDependencyKind;
+}
+/**
+ * Represents a "@rush-temp" scoped package, which has our additional custom field
+ * for tracking the dependency graph.
+ */
+export interface IRushTempPackageJson extends IPackageJson {
+    /**
+     * An extra setting written into package.json for temp packages, to track
+     * references to locally built projects.
+     */
+    rushDependencies?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Represents an NPM package being processed by the linking algorithm.
+ */
+export declare class BasePackage {
+    /**
+     * The "name" field from package.json
+     */
+    name: string;
+    /**
+     * The package.json name can differ from the installation folder name, in the case of an NPM package alias
+     * such as this:
+     *
+     * ```
+     * "dependencies": {
+     *   "@alias-scope/alias-name": "npm:target-name@^1.2.3"
+     * }
+     * ```
+     *
+     * In this case the folder will be `node_modules/@alias-scope/alias-name`
+     * instead of `node_modules/target-name`.
+     */
+    installedName: string;
+    /**
+     * The "version" field from package.json. This is expensive to read
+     * because we have to open the package.json file.  Only when DEBUG=true
+     */
+    version: string | undefined;
+    /**
+     * The absolute path to the folder that contains package.json.
+     */
+    folderPath: string;
+    /**
+     * The parent package, or undefined if this is the root of the tree.
+     */
+    parent: BasePackage | undefined;
+    /**
+     * The raw package.json information for this Package
+     */
+    packageJson: IRushTempPackageJson | undefined;
+    /**
+     * If this is a local path that we are planning to symlink to a target folder,
+     * then symlinkTargetFolderPath keeps track of the intended target.
+     */
+    symlinkTargetFolderPath: string | undefined;
+    /**
+     * Packages that were placed in node_modules subfolders of this package.
+     * The child packages are not necessarily dependencies of this package.
+     */
+    children: BasePackage[];
+    private _childrenByName;
+    protected constructor(name: string, version: string | undefined, folderPath: string, packageJson: IRushTempPackageJson | undefined);
+    /**
+     * Used by link managers, creates a virtual Package object that represents symbolic links
+     * which will be created later
+     */
+    static createLinkedPackage(name: string, version: string | undefined, folderPath: string, packageJson?: IRushTempPackageJson): BasePackage;
+    /**
+     * Used by "npm link" to simulate a temp project that is missing from the common/node_modules
+     * folder (e.g. because it was added after the shrinkwrap file was regenerated).
+     * @param packageJsonFilename - Filename of the source package.json
+     *        Example: `C:\MyRepo\common\temp\projects\project1\package.json`
+     * @param targetFolderName - Filename where it should have been installed
+     *        Example: `C:\MyRepo\common\temp\node_modules\@rush-temp\project1`
+     */
+    static createVirtualTempPackage(packageJsonFilename: string, installFolderName: string): BasePackage;
+    get nameAndVersion(): string;
+    addChild<T extends BasePackage>(child: T): void;
+    getChildByName(childPackageName: string): BasePackage | undefined;
+    printTree(indent?: string): void;
+}
+//# sourceMappingURL=BasePackage.d.ts.map

package/lib/logic/base/BasePackage.js

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

package/lib/logic/base/BaseWorkspaceFile.d.ts

@@ -0,0 +1,31 @@
+export interface IWorkspaceFileSaveOptions {
+    /**
+     * If there is an existing file, and the contents have not changed, then
+     * don't write anything; this preserves the old timestamp.
+     */
+    onlyIfChanged?: boolean;
+    /**
+     * Creates the folder recursively using FileSystem.ensureFolder()
+     * Defaults to false.
+     */
+    ensureFolderExists?: boolean;
+}
+/**
+ * This class is a parser for pnpm's pnpm-workspace.yaml file format.
+ */
+export declare abstract class BaseWorkspaceFile {
+    protected _alreadyWarnedSpecs: Set<string>;
+    /**
+     * Serializes and saves the workspace file to specified location
+     */
+    save(filePath: string, options: IWorkspaceFileSaveOptions): void;
+    /**
+     * Adds a package path to the workspace file.
+     *
+     * @virtual
+     */
+    abstract addPackage(packagePath: string): void;
+    /** @virtual */
+    protected abstract serialize(): string;
+}
+//# sourceMappingURL=BaseWorkspaceFile.d.ts.map

package/lib/logic/base/BaseWorkspaceFile.js

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

package/lib/logic/installManager/RushInstallManager.d.ts

@@ -0,0 +1,77 @@
+import { BaseInstallManager } from '../base/BaseInstallManager';
+import type { IInstallManagerOptions } from '../base/BaseInstallManagerTypes';
+import type { BaseShrinkwrapFile } from '../base/BaseShrinkwrapFile';
+import type { RushGlobalFolder } from '../../api/RushGlobalFolder';
+import type { RushConfiguration } from '../..';
+import type { PurgeManager } from '../PurgeManager';
+import type { Subspace } from '../../api/Subspace';
+/**
+ * The "noMtime" flag is new in tar@4.4.1 and not available yet for \@types/tar.
+ * As a temporary workaround, augment the type.
+ */
+declare module 'tar' {
+    interface CreateOptions {
+        /**
+         * "Set to true to omit writing mtime values for entries. Note that this prevents using other
+         * mtime-based features like tar.update or the keepNewer option with the resulting tar archive."
+         */
+        noMtime?: boolean;
+    }
+}
+/**
+ * This class implements common logic between "rush install" and "rush update".
+ */
+export declare class RushInstallManager extends BaseInstallManager {
+    private _tempProjectHelper;
+    constructor(rushConfiguration: RushConfiguration, rushGlobalFolder: RushGlobalFolder, purgeManager: PurgeManager, options: IInstallManagerOptions);
+    /**
+     * Regenerates the common/package.json and all temp_modules projects.
+     * If shrinkwrapFile is provided, this function also validates whether it contains
+     * everything we need to install and returns true if so; in all other cases,
+     * the return value is false.
+     *
+     * @override
+     */
+    prepareCommonTempAsync(subspace: Subspace, shrinkwrapFile: BaseShrinkwrapFile | undefined): Promise<{
+        shrinkwrapIsUpToDate: boolean;
+        shrinkwrapWarnings: string[];
+    }>;
+    private _revertWorkspaceNotation;
+    private _validateRushProjectTarballIntegrityAsync;
+    /**
+     * Check whether or not the install is already valid, and therefore can be skipped.
+     *
+     * @override
+     */
+    protected canSkipInstallAsync(lastModifiedDate: Date, subspace: Subspace, variant: string | undefined): Promise<boolean>;
+    /**
+     * Runs "npm/pnpm/yarn install" in the "common/temp" folder.
+     *
+     * @override
+     */
+    protected installAsync(cleanInstall: boolean, subspace: Subspace): Promise<void>;
+    protected postInstallAsync(subspace: Subspace): Promise<void>;
+    /**
+     * This is a workaround for a bug introduced in NPM 5 (and still unfixed as of NPM 5.5.1):
+     * https://github.com/npm/npm/issues/19006
+     *
+     * The regression is that "npm install" sets the package.json "version" field for the
+     * @rush-temp projects to a value like "file:projects/example.tgz", when it should be "0.0.0".
+     * This causes linking to fail later, when read-package-tree tries to parse the bad version.
+     * The error looks like this:
+     *
+     * ERROR: Failed to parse package.json for foo: Invalid version: "file:projects/example.tgz"
+     *
+     * Our workaround is to rewrite the package.json files for each of the @rush-temp projects
+     * in the node_modules folder, after "npm install" completes.
+     */
+    private _fixupNpm5RegressionAsync;
+    /**
+     * Checks for temp projects that exist in the shrinkwrap file, but don't exist
+     * in rush.json.  This might occur, e.g. if a project was recently deleted or renamed.
+     *
+     * @returns true if orphans were found, or false if everything is okay
+     */
+    private _findMissingTempProjects;
+}
+//# sourceMappingURL=RushInstallManager.d.ts.map

package/lib/logic/installManager/RushInstallManager.js

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

package/lib/logic/installManager/WorkspaceInstallManager.d.ts

@@ -0,0 +1,46 @@
+import { BaseInstallManager } from '../base/BaseInstallManager';
+import type { IInstallManagerOptions } from '../base/BaseInstallManagerTypes';
+import type { BaseShrinkwrapFile } from '../base/BaseShrinkwrapFile';
+import type { PnpmShrinkwrapFile } from '../pnpm/PnpmShrinkwrapFile';
+import type { Subspace } from '../../api/Subspace';
+export interface IPnpmModules {
+    hoistedDependencies: {
+        [dep in string]: {
+            [depPath in string]: string;
+        };
+    };
+}
+/**
+ * This class implements common logic between "rush install" and "rush update".
+ */
+export declare class WorkspaceInstallManager extends BaseInstallManager {
+    /**
+     * @override
+     */
+    doInstallAsync(): Promise<void>;
+    /**
+     * Regenerates the common/temp/package.json and related workspace files.
+     * If shrinkwrapFile is provided, this function also validates whether it contains
+     * everything we need to install and returns true if so; in all other cases,
+     * the return value is false.
+     *
+     * @override
+     */
+    protected prepareCommonTempAsync(subspace: Subspace, shrinkwrapFile: (PnpmShrinkwrapFile & BaseShrinkwrapFile) | undefined): Promise<{
+        shrinkwrapIsUpToDate: boolean;
+        shrinkwrapWarnings: string[];
+    }>;
+    private _getPackageExtensionChecksum;
+    protected canSkipInstallAsync(lastModifiedDate: Date, subspace: Subspace, variant: string | undefined): Promise<boolean>;
+    /**
+     * Runs "pnpm install" in the common folder.
+     */
+    protected installAsync(cleanInstall: boolean, subspace: Subspace): Promise<void>;
+    protected postInstallAsync(subspace: Subspace): Promise<void>;
+    /**
+     * Used when invoking the NPM tool.  Appends the common configuration options
+     * to the command-line.
+     */
+    protected pushConfigurationArgs(args: string[], options: IInstallManagerOptions, subspace: Subspace): void;
+}
+//# sourceMappingURL=WorkspaceInstallManager.d.ts.map

package/lib/logic/installManager/WorkspaceInstallManager.js

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

package/lib/logic/installManager/doBasicInstallAsync.d.ts

@@ -0,0 +1,17 @@
+import type { ITerminal } from '@rushstack/terminal';
+import type { RushConfiguration } from '../../api/RushConfiguration';
+import type { RushGlobalFolder } from '../../api/RushGlobalFolder';
+import type { IInstallManagerOptions } from '../base/BaseInstallManagerTypes';
+import type { Subspace } from '../../api/Subspace';
+export interface IRunInstallOptions {
+    afterInstallAsync?: IInstallManagerOptions['afterInstallAsync'];
+    beforeInstallAsync?: IInstallManagerOptions['beforeInstallAsync'];
+    rushConfiguration: RushConfiguration;
+    rushGlobalFolder: RushGlobalFolder;
+    isDebug: boolean;
+    terminal: ITerminal;
+    variant: string | undefined;
+    subspace: Subspace;
+}
+export declare function doBasicInstallAsync(options: IRunInstallOptions): Promise<void>;
+//# sourceMappingURL=doBasicInstallAsync.d.ts.map

package/lib/logic/installManager/doBasicInstallAsync.js

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

package/lib/logic/npm/NpmLinkManager.d.ts

@@ -0,0 +1,12 @@
+import { BaseLinkManager } from '../base/BaseLinkManager';
+export declare class NpmLinkManager extends BaseLinkManager {
+    protected _linkProjectsAsync(): Promise<void>;
+    /**
+     * This is called once for each local project from Rush.json.
+     * @param project             The local project that we will create symlinks for
+     * @param commonRootPackage   The common/temp/package.json package
+     * @param commonPackageLookup A dictionary for finding packages under common/temp/node_modules
+     */
+    private _linkProject;
+}
+//# sourceMappingURL=NpmLinkManager.d.ts.map

package/lib/logic/npm/NpmLinkManager.js

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

package/lib/logic/npm/NpmPackage.d.ts

@@ -0,0 +1,86 @@
+import type readPackageTree from 'read-package-tree';
+import { BasePackage } from '../base/BasePackage';
+/**
+ * Used by the linking algorithm when doing NPM package resolution.
+ */
+export interface IResolveOrCreateResult {
+    found: BasePackage | undefined;
+    parentForCreate: BasePackage | undefined;
+}
+/**
+ * The type of dependency; used by IPackageDependency.
+ */
+export declare enum PackageDependencyKind {
+    Normal = 0,
+    /**
+     * The dependency was listed in the optionalDependencies section of package.json.
+     */
+    Optional = 1,
+    /**
+     * The dependency should be a symlink to a project that is locally built by Rush..
+     */
+    LocalLink = 2
+}
+export interface IPackageDependency {
+    /**
+     * The name of the dependency
+     */
+    name: string;
+    /**
+     * The requested version, which may be a pattern such as "^1.2.3"
+     */
+    versionRange: string;
+    /**
+     * The kind of dependency
+     */
+    kind: PackageDependencyKind;
+}
+export declare class NpmPackage extends BasePackage {
+    /**
+     * Names of packages that we explicitly depend on.  The actual dependency
+     * package may be found in this.children, or possibly in this.children of
+     * one of the parents.
+     * If a dependency is listed in the "optionalDependencies" section of package.json
+     * then its name here will be prepended with a "?" character, which means that Rush
+     * will not report an error if the module cannot be found in the Common folder.
+     */
+    dependencies: IPackageDependency[];
+    private constructor();
+    /**
+     * Used by "npm link" when creating a Package object that represents symbolic links to be created.
+     */
+    static createLinkedNpmPackage(name: string, version: string | undefined, dependencies: IPackageDependency[], folderPath: string): NpmPackage;
+    /**
+     * Used by "npm link" to simulate a temp project that is missing from the common/node_modules
+     * folder (e.g. because it was added after the shrinkwrap file was regenerated).
+     * @param packageJsonFilename - Filename of the source package.json
+     *        Example: `C:\MyRepo\common\temp\projects\project1\package.json`
+     * @param targetFolderName - Filename where it should have been installed
+     *        Example: `C:\MyRepo\common\temp\node_modules\@rush-temp\project1`
+     */
+    static createVirtualTempPackage(packageJsonFilename: string, installFolderName: string): NpmPackage;
+    /**
+     * Recursive constructs a tree of NpmPackage objects using information returned
+     * by the "read-package-tree" library.
+     */
+    static createFromNpm(npmPackage: readPackageTree.Node): NpmPackage;
+    /**
+     * Searches the node_modules hierarchy for the nearest matching package with the
+     * given name.  Note that the nearest match may have an incompatible version.
+     * If a match is found, then the "found" result will not be undefined.
+     * In either case, the parentForCreate result indicates where the missing
+     * dependency can be added, i.e. if the requested dependency was not found
+     * or was found with an incompatible version.
+     *
+     * "cyclicSubtreeRoot" is a special optional parameter that specifies a different
+     * root for the tree; the decoupledLocalDependencies feature uses this to isolate
+     * certain devDependencies in their own subtree.
+     */
+    resolveOrCreate(dependencyName: string, cyclicSubtreeRoot?: NpmPackage): IResolveOrCreateResult;
+    /**
+     * Searches the node_modules hierarchy for the nearest matching package with the
+     * given name.  If no match is found, then undefined is returned.
+     */
+    resolve(dependencyName: string): NpmPackage | undefined;
+}
+//# sourceMappingURL=NpmPackage.d.ts.map

package/lib/logic/npm/NpmPackage.js

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

package/lib/logic/operations/BuildPlanPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { ITerminal } from '@rushstack/terminal';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export declare class BuildPlanPlugin implements IPhasedCommandPlugin {
+    private readonly _terminal;
+    constructor(terminal: ITerminal);
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=BuildPlanPlugin.d.ts.map

package/lib/logic/operations/BuildPlanPlugin.js

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

package/lib/logic/operations/ConsoleTimelinePlugin.d.ts

@@ -0,0 +1,26 @@
+import type { ITerminal } from '@rushstack/terminal';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+import type { IExecutionResult } from './IOperationExecutionResult';
+import type { CobuildConfiguration } from '../../api/CobuildConfiguration';
+/**
+ * Phased command plugin that emits a timeline to the console.
+ */
+export declare class ConsoleTimelinePlugin implements IPhasedCommandPlugin {
+    private readonly _terminal;
+    constructor(terminal: ITerminal);
+    apply(hooks: PhasedCommandHooks): void;
+}
+/**
+ * @internal
+ */
+export interface IPrintTimelineParameters {
+    terminal: ITerminal;
+    result: IExecutionResult;
+    cobuildConfiguration: CobuildConfiguration | undefined;
+}
+/**
+ * Print a more detailed timeline and analysis of CPU usage for the build.
+ * @internal
+ */
+export declare function _printTimeline({ terminal, result, cobuildConfiguration }: IPrintTimelineParameters): void;
+//# sourceMappingURL=ConsoleTimelinePlugin.d.ts.map

package/lib/logic/operations/ConsoleTimelinePlugin.js

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

package/lib/logic/operations/IPCOperationRunner.d.ts

@@ -0,0 +1,34 @@
+import type { IPhase } from '../../api/CommandLineConfiguration';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import type { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
+import { OperationStatus } from './OperationStatus';
+export interface IIPCOperationRunnerOptions {
+    phase: IPhase;
+    project: RushConfigurationProject;
+    name: string;
+    shellCommand: string;
+    persist: boolean;
+    requestRun: (requestor?: string) => void;
+}
+/**
+ * Runner that hosts a long-lived process to which it communicates via IPC.
+ */
+export declare class IPCOperationRunner implements IOperationRunner {
+    readonly name: string;
+    readonly cacheable: boolean;
+    readonly reportTiming: boolean;
+    readonly silent: boolean;
+    readonly warningsAreAllowed: boolean;
+    private readonly _rushConfiguration;
+    private readonly _shellCommand;
+    private readonly _workingDirectory;
+    private readonly _persist;
+    private readonly _requestRun;
+    private _ipcProcess;
+    private _processReadyPromise;
+    constructor(options: IIPCOperationRunnerOptions);
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
+    getConfigHash(): string;
+    shutdownAsync(): Promise<void>;
+}
+//# sourceMappingURL=IPCOperationRunner.d.ts.map

package/lib/logic/operations/IPCOperationRunner.js

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

package/lib/logic/operations/IPCOperationRunnerPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+/**
+ * Plugin that implements compatible phases via IPC to a long-lived watch process.
+ */
+export declare class IPCOperationRunnerPlugin implements IPhasedCommandPlugin {
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=IPCOperationRunnerPlugin.d.ts.map

package/lib/logic/operations/IPCOperationRunnerPlugin.js

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

package/lib/logic/operations/PnpmSyncCopyOperationPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { ITerminal } from '@rushstack/terminal';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export declare class PnpmSyncCopyOperationPlugin implements IPhasedCommandPlugin {
+    private readonly _terminal;
+    constructor(terminal: ITerminal);
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=PnpmSyncCopyOperationPlugin.d.ts.map

package/lib/logic/operations/PnpmSyncCopyOperationPlugin.js

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

package/lib/logic/pnpm/PnpmLinkManager.d.ts

@@ -0,0 +1,18 @@
+import { BaseLinkManager } from '../base/BaseLinkManager';
+export declare class PnpmLinkManager extends BaseLinkManager {
+    private readonly _pnpmVersion;
+    /**
+     * @override
+     */
+    createSymlinksForProjectsAsync(force: boolean): Promise<void>;
+    protected _linkProjectsAsync(): Promise<void>;
+    /**
+     * This is called once for each local project from Rush.json.
+     * @param project             The local project that we will create symlinks for
+     * @param rushLinkJson        The common/temp/rush-link.json output file
+     */
+    private _linkProjectAsync;
+    private _getPathToLocalInstallationAsync;
+    private _createLocalPackageForDependency;
+}
+//# sourceMappingURL=PnpmLinkManager.d.ts.map

package/lib/logic/pnpm/PnpmLinkManager.js

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

package/lib/logic/pnpm/PnpmWorkspaceFile.d.ts

@@ -0,0 +1,18 @@
+import { BaseWorkspaceFile } from '../base/BaseWorkspaceFile';
+export declare class PnpmWorkspaceFile extends BaseWorkspaceFile {
+    /**
+     * The filename of the workspace file.
+     */
+    readonly workspaceFilename: string;
+    private _workspacePackages;
+    /**
+     * The PNPM workspace file is used to specify the location of workspaces relative to the root
+     * of your PNPM install.
+     */
+    constructor(workspaceYamlFilename: string);
+    /** @override */
+    addPackage(packagePath: string): void;
+    /** @override */
+    protected serialize(): string;
+}
+//# sourceMappingURL=PnpmWorkspaceFile.d.ts.map

package/lib/logic/pnpm/PnpmWorkspaceFile.js

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

package/lib/utilities/InteractiveUpgradeUI.d.ts

@@ -0,0 +1,22 @@
+/// <reference path="../../src/npm-check-typings.d.ts" />
+import type * as NpmCheck from 'npm-check';
+export interface IUIGroup {
+    title: string;
+    bgColor?: string;
+    filter: {
+        mismatch?: boolean;
+        bump?: undefined | 'major' | 'minor' | 'patch' | 'nonSemver';
+        notInstalled?: boolean;
+    };
+}
+export interface IDepsToUpgradeAnswers {
+    packages: NpmCheck.INpmCheckPackage[];
+}
+export interface IUpgradeInteractiveDepChoice {
+    value: NpmCheck.INpmCheckPackage;
+    name: string | string[];
+    short: string;
+}
+export declare const UI_GROUPS: IUIGroup[];
+export declare const upgradeInteractive: (pkgs: NpmCheck.INpmCheckPackage[]) => Promise<IDepsToUpgradeAnswers>;
+//# sourceMappingURL=InteractiveUpgradeUI.d.ts.map

package/lib/utilities/InteractiveUpgradeUI.js

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

package/lib/utilities/WebClient.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import * as fetch from 'node-fetch';
+/**
+ * For use with {@link WebClient}.
+ */
+export type WebClientResponse = fetch.Response;
+/**
+ * For use with {@link WebClient}.
+ */
+export type WebClientHeaders = fetch.Headers;
+export declare const WebClientHeaders: typeof fetch.Headers;
+/**
+ * For use with {@link WebClient}.
+ */
+export interface IWebFetchOptionsBase {
+    timeoutMs?: number;
+    headers?: WebClientHeaders | Record<string, string>;
+    redirect?: fetch.RequestInit['redirect'];
+}
+/**
+ * For use with {@link WebClient}.
+ */
+export interface IGetFetchOptions extends IWebFetchOptionsBase {
+    verb: 'GET' | never;
+}
+/**
+ * For use with {@link WebClient}.
+ */
+export interface IFetchOptionsWithBody extends IWebFetchOptionsBase {
+    verb: 'PUT' | 'POST' | 'PATCH';
+    body?: Buffer;
+}
+/**
+ * For use with {@link WebClient}.
+ */
+export declare enum WebClientProxy {
+    None = 0,
+    Detect = 1,
+    Fiddler = 2
+}
+/**
+ * A helper for issuing HTTP requests.
+ */
+export declare class WebClient {
+    private static _requestFn;
+    readonly standardHeaders: fetch.Headers;
+    accept: string | undefined;
+    userAgent: string | undefined;
+    proxy: WebClientProxy;
+    static mockRequestFn(fn: typeof fetch.default): void;
+    static resetMockRequestFn(): void;
+    static mergeHeaders(target: fetch.Headers, source: fetch.Headers | Record<string, string>): void;
+    addBasicAuthHeader(userName: string, password: string): void;
+    fetchAsync(url: string, options?: IGetFetchOptions | IFetchOptionsWithBody): Promise<WebClientResponse>;
+}
+//# sourceMappingURL=WebClient.d.ts.map

package/lib/utilities/WebClient.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rushstack/rush-sdk",
-  "version": "5.143.0-pr5009.0",
+  "version": "5.143.0-pr5009.1",
   "description": "An API for interacting with the Rush engine",
   "repository": {
     "type": "git",
@@ -38,18 +38,18 @@
     "tapable": "2.2.1",
     "@rushstack/lookup-by-path": "0.4.5",
     "@rushstack/package-deps-hash": "4.2.10",
-    "@rushstack/terminal": "0.14.3",
-    "@rushstack/node-core-library": "5.10.0"
+    "@rushstack/node-core-library": "5.10.0",
+    "@rushstack/terminal": "0.14.3"
   },
   "devDependencies": {
     "@types/semver": "7.5.0",
     "@types/webpack-env": "1.18.0",
     "webpack": "~5.95.0",
+    "@microsoft/rush-lib": "5.143.0-pr5009.1",
     "@rushstack/heft": "0.68.9",
-    "@microsoft/rush-lib": "5.143.0-pr5009.0",
     "local-node-rig": "1.0.0",
-    "@rushstack/heft-webpack5-plugin": "0.11.7",
     "@rushstack/stream-collator": "4.1.77",
+    "@rushstack/heft-webpack5-plugin": "0.11.7",
     "@rushstack/ts-command-line": "4.23.1",
     "@rushstack/webpack-preserve-dynamic-require-plugin": "0.11.76"
   },