@rushstack/rush-sdk 5.142.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");