@rushstack/rush-sdk 5.90.2 → 5.92.0

package/lib/logic/JsonSchemaUrls.d.ts

@@ -0,0 +1,8 @@
+/**
+ * JSON schema URLs that Rush writes into config files.
+ */
+export declare class JsonSchemaUrls {
+    static readonly approvedPackages: string;
+    static readonly commonVersions: string;
+}
+//# sourceMappingURL=JsonSchemaUrls.d.ts.map

package/lib/logic/JsonSchemaUrls.js

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

package/lib/logic/LookupByPath.d.ts

@@ -0,0 +1,86 @@
+/**
+ * This class is used to associate POSIX relative paths, such as those returned by `git` commands,
+ * with entities that correspond with ancestor folders, such as Rush Projects.
+ *
+ * It is optimized for efficiently locating the nearest ancestor path with an associated value.
+ *
+ * @example
+ * ```ts
+ * const tree = new LookupByPath([['foo', 1], ['bar', 2], ['foo/bar', 3]]);
+ * tree.getNearestAncestor('foo'); // returns 1
+ * tree.getNearestAncestor('foo/baz'); // returns 1
+ * tree.getNearestAncestor('baz'); // returns undefined
+ * tree.getNearestAncestor('foo/bar/baz'); returns 3
+ * tree.getNearestAncestor('bar/foo/bar'); returns 2
+ * ```
+ * @beta
+ */
+export declare class LookupByPath<TItem> {
+    /**
+     * The delimiter used to split paths
+     */
+    readonly delimiter: string;
+    /**
+     * The root node of the tree, corresponding to the path ''
+     */
+    private readonly _root;
+    /**
+     * Constructs a new `LookupByPath`
+     *
+     * @param entries - Initial path-value pairs to populate the tree.
+     */
+    constructor(entries?: Iterable<[string, TItem]>, delimiter?: string);
+    /**
+     * Iterates over the segments of a serialized path.
+     *
+     * @example
+     *
+     * `LookupByPath.iteratePathSegments('foo/bar/baz')` yields 'foo', 'bar', 'baz'
+     *
+     * `LookupByPath.iteratePathSegments('foo\\bar\\baz', '\\')` yields 'foo', 'bar', 'baz'
+     */
+    static iteratePathSegments(serializedPath: string, delimiter?: string): Iterable<string>;
+    /**
+     * Associates the value with the specified serialized path.
+     * If a value is already associated, will overwrite.
+     *
+     * @returns this, for chained calls
+     */
+    setItem(serializedPath: string, value: TItem): this;
+    /**
+     * Associates the value with the specified path.
+     * If a value is already associated, will overwrite.
+     *
+     * @returns this, for chained calls
+     */
+    setItemFromSegments(pathSegments: Iterable<string>, value: TItem): this;
+    /**
+     * Searches for the item associated with `childPath`, or the nearest ancestor of that path that
+     * has an associated item.
+     *
+     * @returns the found item, or `undefined` if no item was found
+     *
+     * @example
+     * ```ts
+     * const tree = new LookupByPath([['foo', 1], ['foo/bar', 2]]);
+     * tree.findChildPath('foo/baz'); // returns 1
+     * tree.findChildPath('foo/bar/baz'); // returns 2
+     * ```
+     */
+    findChildPath(childPath: string): TItem | undefined;
+    /**
+     * Searches for the item associated with `childPathSegments`, or the nearest ancestor of that path that
+     * has an associated item.
+     *
+     * @returns the found item, or `undefined` if no item was found
+     *
+     * @example
+     * ```ts
+     * const tree = new LookupByPath([['foo', 1], ['foo/bar', 2]]);
+     * tree.findChildPathFromSegments(['foo', 'baz']); // returns 1
+     * tree.findChildPathFromSegments(['foo','bar', 'baz']); // returns 2
+     * ```
+     */
+    findChildPathFromSegments(childPathSegments: Iterable<string>): TItem | undefined;
+}
+//# sourceMappingURL=LookupByPath.d.ts.map

package/lib/logic/LookupByPath.js

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

package/lib/logic/NodeJsCompatibility.d.ts

@@ -0,0 +1,42 @@
+import type { RushConfiguration } from '../api/RushConfiguration';
+export interface IWarnAboutVersionTooNewOptions {
+    isRushLib: boolean;
+    /**
+     * The CLI front-end does an early check for NodeJsCompatibility.warnAboutVersionTooNew(),
+     * so this flag is used to avoid reporting the same message twice.  Note that the definition
+     * of "too new" may differ between the globally installed "@microsoft/rush" front end
+     * versus the "@microsoft/rush-lib" loaded by the version selector.
+     */
+    alreadyReportedNodeTooNewError: boolean;
+}
+export interface IWarnAboutCompatibilityIssuesOptions extends IWarnAboutVersionTooNewOptions {
+    rushConfiguration: RushConfiguration | undefined;
+}
+/**
+ * This class provides useful functions for warning if the current Node.js runtime isn't supported.
+ *
+ * @internal
+ */
+export declare class NodeJsCompatibility {
+    /**
+     * This reports if the Node.js version is known to have serious incompatibilities.  In that situation, the user
+     * should downgrade Rush to an older release that supported their Node.js version.
+     */
+    static reportAncientIncompatibleVersion(): boolean;
+    /**
+     * Detect whether the Node.js version is "supported" by the Rush maintainers.  We generally
+     * only support versions that were "Long Term Support" (LTS) at the time when Rush was published.
+     *
+     * This is a warning only -- the user is free to ignore it and use Rush anyway.
+     */
+    static warnAboutCompatibilityIssues(options: IWarnAboutCompatibilityIssuesOptions): boolean;
+    /**
+     * Warn about a Node.js version that has not been tested yet with Rush.
+     */
+    static warnAboutVersionTooNew(options: IWarnAboutVersionTooNewOptions): boolean;
+    private static _warnAboutNonLtsVersion;
+    private static _warnAboutOddNumberedVersion;
+    static get isLtsVersion(): boolean;
+    static get isOddNumberedVersion(): boolean;
+}
+//# sourceMappingURL=NodeJsCompatibility.d.ts.map

package/lib/logic/NodeJsCompatibility.js

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

package/lib/logic/PackageJsonUpdaterTypes.d.ts

@@ -0,0 +1,75 @@
+import type { RushConfigurationProject } from '../api/RushConfigurationProject';
+/**
+ * The type of SemVer range specifier that is prepended to the version
+ */
+export declare const enum SemVerStyle {
+    Exact = "exact",
+    Caret = "caret",
+    Tilde = "tilde",
+    Passthrough = "passthrough"
+}
+export interface IPackageForRushUpdate {
+    packageName: string;
+}
+export interface IPackageForRushAdd extends IPackageForRushUpdate {
+    /**
+     * The style of range that should be used if the version is automatically detected.
+     */
+    rangeStyle: SemVerStyle;
+    /**
+     * If not undefined, the latest version will be used (that doesn't break ensureConsistentVersions).
+     * If specified, the latest version meeting the SemVer specifier will be used as the basis.
+     */
+    version?: string;
+}
+export interface IPackageForRushRemove extends IPackageForRushUpdate {
+}
+export interface IPackageJsonUpdaterRushBaseUpdateOptions {
+    /**
+     * The projects whose package.jsons should get updated
+     */
+    projects: RushConfigurationProject[];
+    /**
+     * The dependencies to be added or removed.
+     */
+    packagesToUpdate: IPackageForRushUpdate[];
+    /**
+     * 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;
+    /**
+     * actionName
+     */
+    actionName: string;
+    /**
+     * The variant to consider when performing installations and validating shrinkwrap updates.
+     */
+    variant?: string | undefined;
+}
+/**
+ * Configuration options for adding or updating a dependency in a single project
+ */
+export interface IPackageJsonUpdaterRushAddOptions extends IPackageJsonUpdaterRushBaseUpdateOptions {
+    /**
+     * Whether or not this dependency should be added as a devDependency or a regular dependency.
+     */
+    devDependency: boolean;
+    /**
+     * If specified, other packages that use this dependency will also have their package.json's updated.
+     */
+    updateOtherPackages: boolean;
+    /**
+     * The dependencies to be added.
+     */
+    packagesToUpdate: IPackageForRushAdd[];
+}
+/**
+ * Options for remove a dependency from a particular project.
+ */
+export interface IPackageJsonUpdaterRushRemoveOptions extends IPackageJsonUpdaterRushBaseUpdateOptions {
+}
+//# sourceMappingURL=PackageJsonUpdaterTypes.d.ts.map

package/lib/logic/PackageJsonUpdaterTypes.js

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

package/lib/logic/PrereleaseToken.d.ts

@@ -0,0 +1,12 @@
+export declare class PrereleaseToken {
+    private _prereleaseName;
+    private _suffixName;
+    private _partialPrerelease;
+    readonly name: string;
+    constructor(prereleaseName?: string, suffixName?: string, partialPrerelease?: boolean);
+    get hasValue(): boolean;
+    get isPrerelease(): boolean;
+    get isSuffix(): boolean;
+    get isPartialPrerelease(): boolean;
+}
+//# sourceMappingURL=PrereleaseToken.d.ts.map

package/lib/logic/PrereleaseToken.js

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

package/lib/logic/ProjectChangeAnalyzer.d.ts

@@ -0,0 +1,81 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { RushConfiguration } from '../api/RushConfiguration';
+import { RushConfigurationProject } from '../api/RushConfigurationProject';
+/**
+ * @beta
+ */
+export interface IGetChangedProjectsOptions {
+    targetBranchName: string;
+    terminal: ITerminal;
+    shouldFetch?: boolean;
+    /**
+     * If set to `true`, consider a project's external dependency installation layout as defined in the
+     * package manager lockfile when determining if it has changed.
+     */
+    includeExternalDependencies: boolean;
+    /**
+     * If set to `true` apply the `incrementalBuildIgnoredGlobs` property in a project's `rush-project.json`
+     * and exclude matched files from change detection.
+     */
+    enableFiltering: boolean;
+}
+/**
+ * @internal
+ */
+export interface IRawRepoState {
+    projectState: Map<RushConfigurationProject, Map<string, string>> | undefined;
+    rootDir: string;
+    rawHashes: Map<string, string>;
+}
+/**
+ * @beta
+ */
+export declare class ProjectChangeAnalyzer {
+    /**
+     * UNINITIALIZED === we haven't looked
+     * undefined === data isn't available (i.e. - git isn't present)
+     */
+    private _data;
+    private readonly _filteredData;
+    private readonly _projectStateCache;
+    private readonly _rushConfiguration;
+    private readonly _git;
+    constructor(rushConfiguration: RushConfiguration);
+    /**
+     * Try to get a list of the specified project's dependencies and their hashes.
+     *
+     * @remarks
+     * If the data can't be generated (i.e. - if Git is not present) this returns undefined.
+     *
+     * @internal
+     */
+    _tryGetProjectDependenciesAsync(project: RushConfigurationProject, terminal: ITerminal): Promise<Map<string, string> | undefined>;
+    /**
+     * @internal
+     */
+    _ensureInitializedAsync(terminal: ITerminal): Promise<IRawRepoState | undefined>;
+    /**
+     * The project state hash is calculated in the following way:
+     * - Project dependencies are collected (see ProjectChangeAnalyzer.getPackageDeps)
+     *   - If project dependencies cannot be collected (i.e. - if Git isn't available),
+     *     this function returns `undefined`
+     * - The (path separator normalized) repo-root-relative dependencies' file paths are sorted
+     * - A SHA1 hash is created and each (sorted) file path is fed into the hash and then its
+     *   Git SHA is fed into the hash
+     * - A hex digest of the hash is returned
+     *
+     * @internal
+     */
+    _tryGetProjectStateHashAsync(project: RushConfigurationProject, terminal: ITerminal): Promise<string | undefined>;
+    _filterProjectDataAsync<T>(project: RushConfigurationProject, unfilteredProjectData: Map<string, T>, rootDir: string, terminal: ITerminal): Promise<Map<string, T>>;
+    /**
+     * Gets a list of projects that have changed in the current state of the repo
+     * when compared to the specified branch, optionally taking the shrinkwrap and settings in
+     * the rush-project.json file into consideration.
+     */
+    getChangedProjectsAsync(options: IGetChangedProjectsOptions): Promise<Set<RushConfigurationProject>>;
+    private _getDataAsync;
+    private _getIgnoreMatcherForProjectAsync;
+    private _getRepoDepsAsync;
+}
+//# sourceMappingURL=ProjectChangeAnalyzer.d.ts.map

package/lib/logic/ProjectChangeAnalyzer.js

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

package/lib/logic/ProjectCommandSet.d.ts

@@ -0,0 +1,13 @@
+import { IPackageJson } from '@rushstack/node-core-library';
+/**
+ * Parses the "scripts" section from package.json and provides support for executing scripts.
+ */
+export declare class ProjectCommandSet {
+    readonly malformedScriptNames: string[];
+    readonly commandNames: string[];
+    private readonly _scriptsByName;
+    constructor(packageJson: IPackageJson);
+    tryGetScriptBody(commandName: string): string | undefined;
+    getScriptBody(commandName: string): string;
+}
+//# sourceMappingURL=ProjectCommandSet.d.ts.map

package/lib/logic/ProjectCommandSet.js

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

package/lib/logic/PublishGit.d.ts

@@ -0,0 +1,19 @@
+import { RushConfigurationProject } from '../api/RushConfigurationProject';
+import { Git } from './Git';
+export declare class PublishGit {
+    private readonly _targetBranch;
+    private readonly _gitPath;
+    private readonly _gitTagSeparator;
+    constructor(git: Git, targetBranch: string | undefined);
+    checkout(branchName: string | undefined, createBranch?: boolean): void;
+    merge(branchName: string, verify?: boolean): void;
+    deleteBranch(branchName: string | undefined, hasRemote?: boolean, verify?: boolean): void;
+    pull(verify?: boolean): void;
+    fetch(): void;
+    addChanges(pathspec?: string, workingDirectory?: string): void;
+    addTag(shouldExecute: boolean, packageName: string, packageVersion: string, commitId: string | undefined, preReleaseName?: string): void;
+    hasTag(packageConfig: RushConfigurationProject): boolean;
+    commit(commitMessage: string, verify?: boolean): void;
+    push(branchName: string | undefined, verify?: boolean): void;
+}
+//# sourceMappingURL=PublishGit.d.ts.map

package/lib/logic/PublishGit.js

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

package/lib/logic/PublishUtilities.d.ts

@@ -0,0 +1,71 @@
+import { type IPackageJson } from '@rushstack/node-core-library';
+import { type IChangeInfo, type IVersionPolicyChangeInfo } from '../api/ChangeManagement';
+import type { RushConfigurationProject } from '../api/RushConfigurationProject';
+import { type IEnvironment } from '../utilities/Utilities';
+import type { PrereleaseToken } from './PrereleaseToken';
+import type { ChangeFiles } from './ChangeFiles';
+import type { RushConfiguration } from '../api/RushConfiguration';
+export interface IChangeRequests {
+    packageChanges: Map<string, IChangeInfo>;
+    versionPolicyChanges: Map<string, IVersionPolicyChangeInfo>;
+}
+export declare class PublishUtilities {
+    /**
+     * Finds change requests in the given folder.
+     * @param changesPath Path to the changes folder.
+     * @returns Dictionary of all change requests, keyed by package name.
+     */
+    static findChangeRequests(allPackages: Map<string, RushConfigurationProject>, rushConfiguration: RushConfiguration, changeFiles: ChangeFiles, includeCommitDetails?: boolean, prereleaseToken?: PrereleaseToken, projectsToExclude?: Set<string>): IChangeRequests;
+    /**
+     * Given the changes hash, flattens them into a sorted array based on their dependency order.
+     * @params packageChanges - hash of change requests.
+     * @returns Sorted array of change requests.
+     */
+    static sortChangeRequests(packageChanges: Map<string, IChangeInfo>): IChangeInfo[];
+    /**
+     * Given a single change request, updates the package json file with updated versions on disk.
+     */
+    static updatePackages(allChanges: IChangeRequests, allPackages: Map<string, RushConfigurationProject>, rushConfiguration: RushConfiguration, shouldCommit: boolean, prereleaseToken?: PrereleaseToken, projectsToExclude?: Set<string>): Map<string, IPackageJson>;
+    /**
+     * Returns the generated tagname to use for a published commit, given package name and version.
+     */
+    static createTagname(packageName: string, version: string, separator?: string): string;
+    static isRangeDependency(version: string): boolean;
+    static getEnvArgs(): {
+        [key: string]: string | undefined;
+    };
+    /**
+     * @param secretSubstring -- if specified, a substring to be replaced by `<<SECRET>>` to avoid printing secrets
+     * on the console
+     */
+    static execCommand(shouldExecute: boolean, command: string, args?: string[], workingDirectory?: string, environment?: IEnvironment, secretSubstring?: string): void;
+    static getNewDependencyVersion(dependencies: {
+        [key: string]: string;
+    }, dependencyName: string, newProjectVersion: string): string;
+    private static _getReleaseType;
+    private static _getChangeTypeForSemverReleaseType;
+    private static _getNewRangeDependency;
+    private static _shouldSkipVersionBump;
+    private static _updateCommitDetails;
+    private static _writePackageChanges;
+    private static _isCyclicDependency;
+    private static _updateDependencies;
+    /**
+     * Gets the new version from the ChangeInfo.
+     * The value of newVersion in ChangeInfo remains unchanged when the change type is dependency,
+     * However, for pre-release build, it won't pick up the updated pre-released dependencies. That is why
+     * this function should return a pre-released patch for that case. The exception to this is when we're
+     * running a partial pre-release build. In this case, only user-changed packages should update.
+     */
+    private static _getChangeInfoNewVersion;
+    /**
+     * Adds the given change to the packageChanges map.
+     *
+     * @returns true if the change caused the dependency change type to increase.
+     */
+    private static _addChange;
+    private static _updateDownstreamDependencies;
+    private static _updateDownstreamDependency;
+    private static _updateDependencyVersion;
+}
+//# sourceMappingURL=PublishUtilities.d.ts.map

package/lib/logic/PublishUtilities.js

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

package/lib/logic/PurgeManager.d.ts

@@ -0,0 +1,29 @@
+import { AsyncRecycler } from '../utilities/AsyncRecycler';
+import { RushConfiguration } from '../api/RushConfiguration';
+import { RushGlobalFolder } from '../api/RushGlobalFolder';
+/**
+ * This class implements the logic for "rush purge"
+ */
+export declare class PurgeManager {
+    private _rushConfiguration;
+    private _rushGlobalFolder;
+    private _rushUserFolderRecycler;
+    readonly commonTempFolderRecycler: AsyncRecycler;
+    constructor(rushConfiguration: RushConfiguration, rushGlobalFolder: RushGlobalFolder);
+    /**
+     * Performs the AsyncRecycler.deleteAll() operation.  This should be called before
+     * the PurgeManager instance is disposed.
+     */
+    deleteAll(): void;
+    /**
+     * Delete everything from the common/temp folder
+     */
+    purgeNormal(): void;
+    /**
+     * In addition to performing the purgeNormal() operation, this method also cleans the
+     * .rush folder in the user's home directory.
+     */
+    purgeUnsafe(): void;
+    private _getMembersToExclude;
+}
+//# sourceMappingURL=PurgeManager.d.ts.map

package/lib/logic/PurgeManager.js

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

package/lib/logic/RepoStateFile.d.ts

@@ -0,0 +1,55 @@
+import { RushConfiguration } from '../api/RushConfiguration';
+/**
+ * This file is used to track the state of various Rush-related features. It is generated
+ * and updated by Rush.
+ *
+ * @public
+ */
+export declare class RepoStateFile {
+    private static _jsonSchema;
+    private _variant;
+    private _pnpmShrinkwrapHash;
+    private _preferredVersionsHash;
+    private _isValid;
+    private _modified;
+    /**
+     * Get the absolute file path of the repo-state.json file.
+     */
+    readonly filePath: string;
+    private constructor();
+    /**
+     * The hash of the pnpm shrinkwrap file at the end of the last update.
+     */
+    get pnpmShrinkwrapHash(): string | undefined;
+    /**
+     * The hash of all preferred versions at the end of the last update.
+     */
+    get preferredVersionsHash(): string | undefined;
+    /**
+     * If false, the repo-state.json file is not valid and its values cannot be relied upon
+     */
+    get isValid(): boolean;
+    /**
+     * Loads the repo-state.json data from the specified file path.
+     * If the file has not been created yet, then an empty object is returned.
+     *
+     * @param jsonFilename - The path to the repo-state.json file.
+     * @param variant - The variant currently being used by Rush.
+     */
+    static loadFromFile(jsonFilename: string, variant: string | undefined): RepoStateFile;
+    /**
+     * Refresh the data contained in repo-state.json using the current state
+     * of the Rush repo, and save the file if changes were made.
+     *
+     * @param rushConfiguration - The Rush configuration for the repo.
+     *
+     * @returns true if the file was modified, otherwise false.
+     */
+    refreshState(rushConfiguration: RushConfiguration): boolean;
+    /**
+     * Writes the "repo-state.json" file to disk, using the filename that was passed to loadFromFile().
+     */
+    private _saveIfModified;
+    private _serialize;
+}
+//# sourceMappingURL=RepoStateFile.d.ts.map

package/lib/logic/RepoStateFile.js

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