@rushstack/rush-sdk 5.90.2 → 5.92.0

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

@@ -0,0 +1,92 @@
+import { DependencySpecifier } from '../DependencySpecifier';
+import { IShrinkwrapFilePolicyValidatorOptions } from '../policy/ShrinkwrapFilePolicy';
+import { RushConfiguration } from '../../api/RushConfiguration';
+import { IExperimentsJson } from '../../api/ExperimentsConfiguration';
+import { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import { BaseProjectShrinkwrapFile } from './BaseProjectShrinkwrapFile';
+import { PackageManagerOptionsConfigurationBase } from './BasePackageManagerOptionsConfiguration';
+/**
+ * This class is a parser for both npm's npm-shrinkwrap.json and pnpm's pnpm-lock.yaml file formats.
+ */
+export declare abstract class BaseShrinkwrapFile {
+    abstract readonly isWorkspaceCompatible: boolean;
+    protected _alreadyWarnedSpecs: Set<string>;
+    protected static tryGetValue<T>(dictionary: {
+        [key2: string]: T;
+    }, key: string): T | undefined;
+    /**
+     * Validate the shrinkwrap using the provided policy options.
+     *
+     * @virtual
+     */
+    validate(packageManagerOptionsConfig: PackageManagerOptionsConfigurationBase, policyOptions: IShrinkwrapFilePolicyValidatorOptions, experimentsConfig?: IExperimentsJson): void;
+    /**
+     * Returns true if the shrinkwrap file includes a top-level package that would satisfy the specified
+     * package name and SemVer version range
+     *
+     * @virtual
+     */
+    hasCompatibleTopLevelDependency(dependencySpecifier: DependencySpecifier): boolean;
+    /**
+     * Returns true if the shrinkwrap file includes a package that would satisfying the specified
+     * package name and SemVer version range.  By default, the dependencies are resolved by looking
+     * at the root of the node_modules folder described by the shrinkwrap file.  However, if
+     * tempProjectName is specified, then the resolution will start in that subfolder.
+     *
+     * Consider this example:
+     *
+     * - node_modules\
+     *   - temp-project\
+     *     - lib-a@1.2.3
+     *     - lib-b@1.0.0
+     *   - lib-b@2.0.0
+     *
+     * In this example, hasCompatibleDependency("lib-b", ">= 1.1.0", "temp-project") would fail
+     * because it finds lib-b@1.0.0 which does not satisfy the pattern ">= 1.1.0".
+     *
+     * @virtual
+     */
+    tryEnsureCompatibleDependency(dependencySpecifier: DependencySpecifier, tempProjectName: string): boolean;
+    /**
+     * Returns the list of temp projects defined in this file.
+     * Example: [ '@rush-temp/project1', '@rush-temp/project2' ]
+     *
+     * @virtual
+     */
+    abstract getTempProjectNames(): ReadonlyArray<string>;
+    /** @virtual */
+    protected abstract tryEnsureDependencyVersion(dependencySpecifier: DependencySpecifier, tempProjectName: string): DependencySpecifier | undefined;
+    /** @virtual */
+    protected abstract getTopLevelDependencyVersion(dependencyName: string): DependencySpecifier | undefined;
+    /**
+     * Check for 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 a list of orphaned projects.
+     */
+    findOrphanedProjects(rushConfiguration: RushConfiguration): ReadonlyArray<string>;
+    /**
+     * Returns a project shrinkwrap file for the specified project that contains all dependencies and transitive
+     * dependencies.
+     *
+     * @virtual
+     **/
+    abstract getProjectShrinkwrap(project: RushConfigurationProject): BaseProjectShrinkwrapFile<BaseShrinkwrapFile> | undefined;
+    /**
+     * Returns whether or not the workspace specified by the shrinkwrap matches the state of
+     * a given package.json. Returns true if any dependencies are not aligned with the shrinkwrap.
+     *
+     * @param project - the Rush project that is being validated against the shrinkwrap
+     * @param variant - the variant that is being validated
+     *
+     * @virtual
+     */
+    abstract isWorkspaceProjectModifiedAsync(project: RushConfigurationProject, variant?: string): Promise<boolean>;
+    /** @virtual */
+    protected abstract serialize(): string;
+    protected _getTempProjectNames(dependencies: {
+        [key: string]: {};
+    }): ReadonlyArray<string>;
+    private _checkDependencyVersion;
+}
+//# sourceMappingURL=BaseShrinkwrapFile.d.ts.map

package/lib/logic/base/BaseShrinkwrapFile.js

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

package/lib/logic/buildCache/CacheEntryId.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Options for generating the cache id for an operation.
+ * @beta
+ */
+export interface IGenerateCacheEntryIdOptions {
+    /**
+     * The name of the project
+     */
+    projectName: string;
+    /**
+     * The name of the phase
+     */
+    phaseName: string;
+    /**
+     * A hash of the input files
+     */
+    projectStateHash: string;
+}
+/**
+ * Calculates the cache entry id string for an operation.
+ * @beta
+ */
+export declare type GetCacheEntryIdFunction = (options: IGenerateCacheEntryIdOptions) => string;
+export declare class CacheEntryId {
+    private constructor();
+    static parsePattern(pattern?: string): GetCacheEntryIdFunction;
+}
+//# sourceMappingURL=CacheEntryId.d.ts.map

package/lib/logic/buildCache/CacheEntryId.js

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

package/lib/logic/buildCache/FileSystemBuildCacheProvider.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { ITerminal } from '@rushstack/node-core-library';
+import { RushConfiguration } from '../../api/RushConfiguration';
+import { RushUserConfiguration } from '../../api/RushUserConfiguration';
+/**
+ * Options for creating a file system build cache provider.
+ * @beta
+ */
+export interface IFileSystemBuildCacheProviderOptions {
+    /**
+     * The workspace Rush configuration
+     */
+    rushConfiguration: RushConfiguration;
+    /**
+     * The user Rush configuration
+     */
+    rushUserConfiguration: RushUserConfiguration;
+}
+/**
+ * A build cache provider using the local file system.
+ * Required by all cloud cache providers.
+ * @beta
+ */
+export declare class FileSystemBuildCacheProvider {
+    private readonly _cacheFolderPath;
+    constructor(options: IFileSystemBuildCacheProviderOptions);
+    /**
+     * Returns the absolute disk path for the specified cache id.
+     */
+    getCacheEntryPath(cacheId: string): string;
+    /**
+     * Validates that the specified cache id exists on disk, and returns the path if it does.
+     */
+    tryGetCacheEntryPathByIdAsync(terminal: ITerminal, cacheId: string): Promise<string | undefined>;
+    /**
+     * Writes the specified buffer to the corresponding file system path for the cache id.
+     */
+    trySetCacheEntryBufferAsync(terminal: ITerminal, cacheId: string, entryBuffer: Buffer): Promise<string>;
+}
+//# sourceMappingURL=FileSystemBuildCacheProvider.d.ts.map

package/lib/logic/buildCache/FileSystemBuildCacheProvider.js

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

package/lib/logic/buildCache/ICloudBuildCacheProvider.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { ITerminal } from '@rushstack/node-core-library';
+/**
+ * @beta
+ */
+export interface ICloudBuildCacheProvider {
+    readonly isCacheWriteAllowed: boolean;
+    tryGetCacheEntryBufferByIdAsync(terminal: ITerminal, cacheId: string): Promise<Buffer | undefined>;
+    trySetCacheEntryBufferAsync(terminal: ITerminal, cacheId: string, entryBuffer: Buffer): Promise<boolean>;
+    updateCachedCredentialAsync(terminal: ITerminal, credential: string): Promise<void>;
+    updateCachedCredentialInteractiveAsync(terminal: ITerminal): Promise<void>;
+    deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void>;
+}
+//# sourceMappingURL=ICloudBuildCacheProvider.d.ts.map

package/lib/logic/buildCache/ICloudBuildCacheProvider.js

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

package/lib/logic/buildCache/ProjectBuildCache.d.ts

@@ -0,0 +1,46 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { ProjectChangeAnalyzer } from '../ProjectChangeAnalyzer';
+import { RushProjectConfiguration } from '../../api/RushProjectConfiguration';
+import { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
+export interface IProjectBuildCacheOptions {
+    buildCacheConfiguration: BuildCacheConfiguration;
+    projectConfiguration: RushProjectConfiguration;
+    projectOutputFolderNames: ReadonlyArray<string>;
+    additionalProjectOutputFilePaths?: ReadonlyArray<string>;
+    additionalContext?: Record<string, string>;
+    command: string;
+    trackedProjectFiles: string[] | undefined;
+    projectChangeAnalyzer: ProjectChangeAnalyzer;
+    terminal: ITerminal;
+    phaseName: string;
+}
+export declare class ProjectBuildCache {
+    /**
+     * null === we haven't tried to initialize yet
+     * undefined === unable to initialize
+     */
+    private static _tarUtilityPromise;
+    private readonly _project;
+    private readonly _localBuildCacheProvider;
+    private readonly _cloudBuildCacheProvider;
+    private readonly _buildCacheEnabled;
+    private readonly _cacheWriteEnabled;
+    private readonly _projectOutputFolderNames;
+    private readonly _additionalProjectOutputFilePaths;
+    private _cacheId;
+    private constructor();
+    private static _tryGetTarUtility;
+    static tryGetProjectBuildCache(options: IProjectBuildCacheOptions): Promise<ProjectBuildCache | undefined>;
+    private static _validateProject;
+    tryRestoreFromCacheAsync(terminal: ITerminal): Promise<boolean>;
+    trySetCacheEntryAsync(terminal: ITerminal): Promise<boolean>;
+    /**
+     * Walks the declared output folders of the project and collects a list of files.
+     * @returns The list of output files as project-relative paths, or `undefined` if a
+     *   symbolic link was encountered.
+     */
+    private _tryCollectPathsToCacheAsync;
+    private _getTarLogFilePath;
+    private static _getCacheId;
+}
+//# sourceMappingURL=ProjectBuildCache.d.ts.map

package/lib/logic/buildCache/ProjectBuildCache.js

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

package/lib/logic/buildCache/getHashesForGlobsAsync.d.ts

@@ -0,0 +1,3 @@
+import type { IRawRepoState } from '../ProjectChangeAnalyzer';
+export declare function getHashesForGlobsAsync(globPatterns: Iterable<string>, packagePath: string, repoState: IRawRepoState | undefined): Promise<Map<string, string>>;
+//# sourceMappingURL=getHashesForGlobsAsync.d.ts.map

package/lib/logic/buildCache/getHashesForGlobsAsync.js

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

package/lib/logic/deploy/DeployScenarioConfiguration.d.ts

@@ -0,0 +1,39 @@
+import { RushConfiguration } from '../../api/RushConfiguration';
+export interface IDeployScenarioProjectJson {
+    projectName: string;
+    additionalProjectsToInclude?: string[];
+    additionalDependenciesToInclude?: string[];
+    dependenciesToExclude?: string[];
+}
+export interface IDeployScenarioJson {
+    deploymentProjectNames: string[];
+    includeDevDependencies?: boolean;
+    includeNpmIgnoreFiles?: boolean;
+    omitPnpmWorkaroundLinks?: boolean;
+    linkCreation?: 'default' | 'script' | 'none';
+    folderToCopy?: string;
+    projectSettings?: IDeployScenarioProjectJson[];
+}
+export declare class DeployScenarioConfiguration {
+    private static _scenarioNameRegExp;
+    private static _jsonSchema;
+    readonly json: IDeployScenarioJson;
+    /**
+     * Used to lookup items in IDeployScenarioJson.projectSettings based on their IDeployScenarioProjectJson.projectName
+     */
+    readonly projectJsonsByName: Map<string, IDeployScenarioProjectJson>;
+    private constructor();
+    /**
+     * Validates that the input string conforms to the naming rules for a "rush deploy" scenario name.
+     */
+    static validateScenarioName(scenarioName: string): void;
+    /**
+     * Given the --scenarioName value, return the full path of the filename.
+     *
+     * Example: "ftp-site" --> "...common/config/rush/deploy-ftp-site.json"
+     * Example: undefined --> "...common/config/rush/deploy.json"
+     */
+    static getConfigFilePath(scenarioName: string | undefined, rushConfiguration: RushConfiguration): string;
+    static loadFromFile(scenarioFilePath: string, rushConfiguration: RushConfiguration): DeployScenarioConfiguration;
+}
+//# sourceMappingURL=DeployScenarioConfiguration.d.ts.map

package/lib/logic/deploy/DeployScenarioConfiguration.js

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

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

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { RushConfiguration } from '../../api/RushConfiguration';
+import { RushGlobalFolder } from '../../api/RushGlobalFolder';
+export declare class InstallHelpers {
+    static generateCommonPackageJson(rushConfiguration: RushConfiguration, dependencies?: Map<string, string>): void;
+    static getPackageManagerEnvironment(rushConfiguration: RushConfiguration, options?: {
+        debug?: boolean;
+    }): NodeJS.ProcessEnv;
+    /**
+     * If the "(p)npm-local" symlink hasn't been set up yet, this creates it, installing the
+     * specified (P)npm version in the user's home directory if needed.
+     */
+    static ensureLocalPackageManager(rushConfiguration: RushConfiguration, rushGlobalFolder: RushGlobalFolder, maxInstallAttempts: number, restrictConsoleOutput?: boolean): Promise<void>;
+    private static _mergeEnvironmentVariables;
+}
+//# sourceMappingURL=InstallHelpers.d.ts.map

package/lib/logic/installManager/InstallHelpers.js

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

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

@@ -0,0 +1,21 @@
+import { IPackageManagerOptionsJsonBase, PackageManagerOptionsConfigurationBase } from '../base/BasePackageManagerOptionsConfiguration';
+/**
+ * Part of IRushConfigurationJson.
+ * @internal
+ */
+export interface INpmOptionsJson extends IPackageManagerOptionsJsonBase {
+}
+/**
+ * Options that are only used when the NPM package manager is selected.
+ *
+ * @remarks
+ * It is valid to define these options in rush.json even if the NPM package manager
+ * is not being used.
+ *
+ * @public
+ */
+export declare class NpmOptionsConfiguration extends PackageManagerOptionsConfigurationBase {
+    /** @internal */
+    constructor(json: INpmOptionsJson);
+}
+//# sourceMappingURL=NpmOptionsConfiguration.d.ts.map

package/lib/logic/npm/NpmOptionsConfiguration.js

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

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

@@ -0,0 +1,29 @@
+import { BaseShrinkwrapFile } from '../base/BaseShrinkwrapFile';
+import { DependencySpecifier } from '../DependencySpecifier';
+import { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import { BaseProjectShrinkwrapFile } from '../base/BaseProjectShrinkwrapFile';
+export declare class NpmShrinkwrapFile extends BaseShrinkwrapFile {
+    readonly isWorkspaceCompatible: boolean;
+    private _shrinkwrapJson;
+    private constructor();
+    static loadFromFile(shrinkwrapJsonFilename: string): NpmShrinkwrapFile | undefined;
+    static loadFromString(shrinkwrapContent: string): NpmShrinkwrapFile;
+    /** @override */
+    getTempProjectNames(): ReadonlyArray<string>;
+    /** @override */
+    protected serialize(): string;
+    /** @override */
+    protected getTopLevelDependencyVersion(dependencyName: string): DependencySpecifier | undefined;
+    /**
+     * @param dependencyName the name of the dependency to get a version for
+     * @param tempProjectName the name of the temp project to check for this dependency
+     * @param versionRange Not used, just exists to satisfy abstract API contract
+     * @override
+     */
+    protected tryEnsureDependencyVersion(dependencySpecifier: DependencySpecifier, tempProjectName: string): DependencySpecifier | undefined;
+    /** @override */
+    getProjectShrinkwrap(project: RushConfigurationProject): BaseProjectShrinkwrapFile<NpmShrinkwrapFile> | undefined;
+    /** @override */
+    isWorkspaceProjectModifiedAsync(project: RushConfigurationProject, variant?: string): Promise<boolean>;
+}
+//# sourceMappingURL=NpmShrinkwrapFile.d.ts.map

package/lib/logic/npm/NpmShrinkwrapFile.js

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

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

@@ -0,0 +1,47 @@
+import { OperationExecutionRecord } from './OperationExecutionRecord';
+/**
+ * Implmentation of the async iteration protocol for a collection of IOperation objects.
+ * The async iterator will wait for an operation to be ready for execution, or terminate if there are no more operations.
+ *
+ * @remarks
+ * If the caller does not update dependencies prior to invoking `next()` on the iterator again,
+ * it must manually invoke `assignOperations()` after performing the updates, otherwise iterators will
+ * stall until another operations completes.
+ */
+export declare class AsyncOperationQueue implements AsyncIterable<OperationExecutionRecord>, AsyncIterator<OperationExecutionRecord> {
+    private readonly _queue;
+    private readonly _pendingIterators;
+    /**
+     * @param operations - The set of operations to be executed
+     * @param sortFn - A function that sorts operations in reverse priority order:
+     *   - Returning a positive value indicates that `a` should execute before `b`.
+     *   - Returning a negative value indicates that `b` should execute before `a`.
+     *   - Returning 0 indicates no preference.
+     */
+    constructor(operations: Iterable<OperationExecutionRecord>, sortFn: IOperationSortFunction);
+    /**
+     * For use with `for await (const operation of taskQueue)`
+     * @see {AsyncIterator}
+     */
+    next(): Promise<IteratorResult<OperationExecutionRecord>>;
+    /**
+     * Routes ready operations with 0 dependencies to waiting iterators. Normally invoked as part of `next()`, but
+     * if the caller does not update operation dependencies prior to calling `next()`, may need to be invoked manually.
+     */
+    assignOperations(): void;
+    /**
+     * Returns this queue as an async iterator, such that multiple functions iterating this object concurrently
+     * receive distinct iteration results.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<OperationExecutionRecord>;
+}
+export interface IOperationSortFunction {
+    /**
+     * A function that sorts operations in reverse priority order:
+     * Returning a positive value indicates that `a` should execute before `b`.
+     * Returning a negative value indicates that `b` should execute before `a`.
+     * Returning 0 indicates no preference.
+     */
+    (a: OperationExecutionRecord, b: OperationExecutionRecord): number;
+}
+//# sourceMappingURL=AsyncOperationQueue.d.ts.map

package/lib/logic/operations/AsyncOperationQueue.js

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

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

@@ -0,0 +1,49 @@
+import type { StdioSummarizer } from '@rushstack/terminal';
+import type { OperationStatus } from './OperationStatus';
+import type { IStopwatchResult } from '../../utilities/Stopwatch';
+import type { Operation } from './Operation';
+/**
+ * The `IOperationExecutionResult` interface represents the results of executing an {@link Operation}.
+ * @alpha
+ */
+export interface IOperationExecutionResult {
+    /**
+     * The current execution status of an operation. Operations start in the 'ready' state,
+     * but can be 'blocked' if an upstream operation failed. It is 'executing' when
+     * the operation is executing. Once execution is complete, it is either 'success' or
+     * 'failure'.
+     */
+    readonly status: OperationStatus;
+    /**
+     * The error which occurred while executing this operation, this is stored in case we need
+     * it later (for example to re-print errors at end of execution).
+     */
+    readonly error: Error | undefined;
+    /**
+     * Object tracking execution timing.
+     */
+    readonly stopwatch: IStopwatchResult;
+    /**
+     * Object used to report a summary at the end of the Rush invocation.
+     */
+    readonly stdioSummarizer: StdioSummarizer;
+    /**
+     * The value indicates the duration of the same operation without cache hit.
+     */
+    readonly nonCachedDurationMs: number | undefined;
+}
+/**
+ * The `IExecutionResult` interface represents the results of executing a set of {@link Operation}s.
+ * @alpha
+ */
+export interface IExecutionResult {
+    /**
+     * The results for each scheduled operation.
+     */
+    readonly operationResults: ReadonlyMap<Operation, IOperationExecutionResult>;
+    /**
+     * The overall result.
+     */
+    readonly status: OperationStatus;
+}
+//# sourceMappingURL=IOperationExecutionResult.d.ts.map

package/lib/logic/operations/IOperationExecutionResult.js

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

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

@@ -0,0 +1,77 @@
+import type { StdioSummarizer } from '@rushstack/terminal';
+import type { CollatedWriter } from '@rushstack/stream-collator';
+import type { OperationStatus } from './OperationStatus';
+import type { OperationMetadataManager } from './OperationMetadataManager';
+import type { IStopwatchResult } from '../../utilities/Stopwatch';
+/**
+ * Information passed to the executing `IOperationRunner`
+ *
+ * @beta
+ */
+export interface IOperationRunnerContext {
+    /**
+     * The writer into which this `IOperationRunner` should write its logs.
+     */
+    collatedWriter: CollatedWriter;
+    /**
+     * If Rush was invoked with `--debug`
+     */
+    debugMode: boolean;
+    /**
+     * Defaults to `true`. Will be `false` if Rush was invoked with `--verbose`.
+     */
+    quietMode: boolean;
+    /**
+     * Object used to report a summary at the end of the Rush invocation.
+     */
+    stdioSummarizer: StdioSummarizer;
+    /**
+     * Object used to manage metadata of the operation.
+     *
+     * @internal
+     */
+    _operationMetadataManager?: OperationMetadataManager;
+    /**
+     * Object used to track elapsed time.
+     */
+    stopwatch: IStopwatchResult;
+}
+/**
+ * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
+ * `OperationExecutionManager`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
+ * implementation manages the actual process for running a single operation.
+ *
+ * @beta
+ */
+export interface IOperationRunner {
+    /**
+     * Name of the operation, for logging.
+     */
+    readonly name: string;
+    /**
+     * This flag determines if the operation is allowed to be skipped if up to date.
+     */
+    isSkipAllowed: boolean;
+    /**
+     * Indicates that this runner's duration has meaning.
+     */
+    reportTiming: boolean;
+    /**
+     * Indicates that this runner is architectural and should not be reported on.
+     */
+    silent: boolean;
+    /**
+     * If set to true, a warning result should not make Rush exit with a nonzero
+     * exit code
+     */
+    warningsAreAllowed: boolean;
+    /**
+     * Indicates if the output of this operation may be written to the cache
+     */
+    isCacheWriteAllowed: boolean;
+    /**
+     * Method to be executed for the operation.
+     */
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
+}
+//# sourceMappingURL=IOperationRunner.d.ts.map

package/lib/logic/operations/IOperationRunner.js

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

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

@@ -0,0 +1,35 @@
+import type { OperationStatus } from './OperationStatus';
+import type { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
+/**
+ *
+ */
+export interface INullOperationRunnerParams {
+    /**
+     * The name to report in logs.
+     */
+    name: string;
+    /**
+     * The result to report from the runner.
+     */
+    result: OperationStatus;
+    /**
+     * If true, the operation will not log anything or be tracked in statistics.
+     */
+    silent: boolean;
+}
+/**
+ * Implementation of `IOperationRunner` for operations that require no work, such as empty scripts,
+ * skipped operations, or blocked operations.
+ */
+export declare class NullOperationRunner implements IOperationRunner {
+    readonly name: string;
+    readonly reportTiming: boolean;
+    readonly silent: boolean;
+    isSkipAllowed: boolean;
+    isCacheWriteAllowed: boolean;
+    readonly warningsAreAllowed: boolean;
+    readonly result: OperationStatus;
+    constructor({ name, result, silent }: INullOperationRunnerParams);
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
+}
+//# sourceMappingURL=NullOperationRunner.d.ts.map

package/lib/logic/operations/NullOperationRunner.js

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