@rushstack/rush-sdk 5.170.1-pr5378.0 → 5.171.0

package/lib-dts/logic/operations/OperationGraph.d.ts

@@ -1,125 +0,0 @@
-import { type TerminalWritable } from '@rushstack/terminal';
-import type { Operation } from './Operation';
-import { OperationStatus } from './OperationStatus';
-import { OperationExecutionRecord } from './OperationExecutionRecord';
-import type { IExecutionResult } from './IOperationExecutionResult';
-import type { IInputsSnapshot } from '../incremental/InputsSnapshot';
-import type { IOperationGraph, IOperationGraphIterationOptions } from './IOperationGraph';
-import { OperationGraphHooks } from '../../pluginFramework/OperationGraphHooks';
-import { type Parallelism } from './ParseParallelism';
-import type { ITelemetryData } from '../Telemetry';
-export interface IOperationGraphTelemetry {
-    initialExtraData: Record<string, unknown>;
-    changedProjectsOnlyKey: string | undefined;
-    nameForLog: string;
-    log: (telemetry: ITelemetryData) => void;
-}
-export interface IOperationGraphOptions {
-    quietMode: boolean;
-    debugMode: boolean;
-    parallelism: Parallelism;
-    allowOversubscription: boolean;
-    destinations: Iterable<TerminalWritable>;
-    /** Optional maximum allowed parallelism. Defaults to `getNumberOfCores()`. */
-    maxParallelism?: number;
-    /**
-     * Controller used to signal abortion of the entire execution session (e.g. terminating watch mode).
-     * Consumers (e.g. ProjectWatcher) can subscribe to this to perform cleanup.
-     */
-    abortController: AbortController;
-    isWatch?: boolean;
-    pauseNextIteration?: boolean;
-    telemetry?: IOperationGraphTelemetry;
-    getInputsSnapshotAsync?: () => Promise<IInputsSnapshot | undefined>;
-}
-/**
- * A class which manages the execution of a set of tasks with interdependencies.
- */
-export declare class OperationGraph implements IOperationGraph {
-    readonly hooks: OperationGraphHooks;
-    readonly operations: Set<Operation>;
-    readonly abortController: AbortController;
-    private readonly _sortedOperations;
-    resultByOperation: Map<Operation, OperationExecutionRecord>;
-    private _parallelism;
-    private _maxParallelism;
-    private _debugMode;
-    private _quietMode;
-    private _allowOversubscription;
-    private _pauseNextIteration;
-    private readonly _isWatch;
-    private readonly _telemetry;
-    private readonly _getInputsSnapshotAsync;
-    /**
-     * Records invalidated during the current iteration that could not be marked `Ready` immediately
-     * because their record object is shared between `resultByOperation` and the active iteration's
-     * `records` map (mutating it mid-iteration would corrupt the summarizer's view of results).
-     * Maps each record to the invalidation reason; applied once the iteration completes.
-     */
-    private readonly _deferredInvalidations;
-    private _currentIteration;
-    private _scheduledIteration;
-    private _terminalSplitter;
-    private _idleTimeout;
-    /** Tracks if a graph state change notification has been scheduled for next tick. */
-    private _graphStateChangeScheduled;
-    private _status;
-    constructor(operations: Set<Operation>, options: IOperationGraphOptions);
-    /**
-     * {@inheritDoc IOperationGraph.setEnabledStates}
-     */
-    setEnabledStates(operations: Iterable<Operation>, targetState: Operation['enabled'], mode: 'safe' | 'unsafe'): boolean;
-    get parallelism(): number;
-    set parallelism(value: Parallelism);
-    get debugMode(): boolean;
-    set debugMode(value: boolean);
-    get quietMode(): boolean;
-    set quietMode(value: boolean);
-    get allowOversubscription(): boolean;
-    set allowOversubscription(value: boolean);
-    get pauseNextIteration(): boolean;
-    set pauseNextIteration(value: boolean);
-    get hasScheduledIteration(): boolean;
-    get status(): OperationStatus;
-    get terminalDestinations(): ReadonlySet<TerminalWritable>;
-    private _setStatus;
-    private _setScheduledIteration;
-    closeRunnersAsync(operations?: Operation[]): Promise<void>;
-    invalidateOperations(operations?: Iterable<Operation>, reason?: string): void;
-    /**
-     * Shorthand for scheduling an iteration then executing it.
-     * Call `abortCurrentIterationAsync()` to cancel the execution of any operations that have not yet begun execution.
-     * @param iterationOptions - Options for this execution iteration.
-     * @returns A promise which is resolved when all operations have been processed to a final state.
-     */
-    executeAsync(iterationOptions: IOperationGraphIterationOptions): Promise<IExecutionResult>;
-    /**
-     * Queues a new execution iteration.
-     * @param iterationOptions - Options for this execution iteration.
-     * @returns A promise that resolves to true if the iteration was successfully queued, or false if it was not.
-     */
-    scheduleIterationAsync(iterationOptions: IOperationGraphIterationOptions): Promise<boolean>;
-    /**
-     * Executes all operations which have been registered, returning a promise which is resolved when all operations have been processed to a final state.
-     * Aborts the current iteration first, if any.
-     */
-    executeScheduledIterationAsync(): Promise<boolean>;
-    abortCurrentIterationAsync(): Promise<void>;
-    addTerminalDestination(destination: TerminalWritable): void;
-    removeTerminalDestination(destination: TerminalWritable, close?: boolean): boolean;
-    private _setIdleTimeout;
-    private _onIdle;
-    private _scheduleIterationAsync;
-    /**
-     * Debounce configuration change notifications so that multiple property setters invoked within the same tick
-     * only trigger the hook once. This avoids redundant re-computation in listeners (e.g. UI refresh) while preserving
-     * ordering guarantees that the notification occurs after the initiating state changes are fully applied.
-     */
-    private _scheduleManagerStateChanged;
-    /**
-     * Executes all operations which have been registered, returning a promise which is resolved when all operations have been processed to a final state.
-     * The abortController can be used to cancel the execution of any operations that have not yet begun execution.
-     */
-    private _executeInnerAsync;
-}
-//# sourceMappingURL=OperationGraph.d.ts.map

package/lib-dts/logic/operations/ParseParallelism.d.ts

@@ -1,33 +0,0 @@
-export declare function getNumberOfCores(): number;
-/**
- * A parallelism value expressed as a fraction of total available concurrency slots.
- * @beta
- */
-export interface IParallelismScalar {
-    readonly scalar: number;
-}
-/**
- * A parallelism value, either as an absolute integer count or a scalar fraction of available parallelism.
- * @beta
- */
-export type Parallelism = number | IParallelismScalar;
-/**
- * Since the JSON value is a string, it must be a percentage like "50%",
- * which we parse into a scalar in the range (0, 1].
- * The caller is responsible for multiplying by the available parallelism.
- */
-export declare function parseParallelismPercent(weight: string): number;
-/**
- * Coerces a `Parallelism` value to a concrete integer number of concurrency units, given the
- * maximum number of available slots.
- *
- * - Raw numeric values are clamped to `[minimum, maxParallelism]`.
- * - Scalar values are multiplied by `maxParallelism`, floored, and clamped to `[Math.max(1, minimum), maxParallelism]`.
- */
-export declare function coerceParallelism(parallelism: Parallelism, maxParallelism: number, minimum?: number): number;
-/**
- * Parses a command line specification for desired parallelism.
- * Factored out to enable unit tests
- */
-export declare function parseParallelism(rawParallelism: string | undefined): Parallelism;
-//# sourceMappingURL=ParseParallelism.d.ts.map

package/lib-dts/pluginFramework/OperationGraphHooks.d.ts

@@ -1,129 +0,0 @@
-import { AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook, SyncWaterfallHook } from 'tapable';
-import type { Operation } from '../logic/operations/Operation';
-import type { IOperationExecutionResult, IConfigurableOperation } from '../logic/operations/IOperationExecutionResult';
-import type { OperationStatus } from '../logic/operations/OperationStatus';
-import type { IOperationRunnerContext } from '../logic/operations/IOperationRunner';
-import type { ITelemetryData } from '../logic/Telemetry';
-import type { IEnvironment } from '../utilities/Utilities';
-import type { IOperationGraph, IOperationGraphIterationOptions } from '../logic/operations/IOperationGraph';
-/**
- * Hooks into the execution process for operations within the graph.
- *
- * Per-iteration lifecycle:
- * 1. `configureIteration` - Synchronously decide which operations to enable for the next iteration.
- * 2. `onIterationScheduled` - Fires after the iteration is prepared but before execution begins, if it has any enabled operations.
- * 3. `beforeExecuteIterationAsync` - Async hook that can bail out the iteration entirely.
- * 4. Operations execute (status changes reported via `onExecutionStatesUpdated`).
- * 5. `afterExecuteIterationAsync` - Fires after all operations in the iteration have settled.
- * 6. `onIdle` - Fires when the graph enters idle state awaiting changes (watch mode only).
- *
- * Additional hooks:
- * - `onEnableStatesChanged` - Fires when `setEnabledStates` mutates operation enabled flags.
- * - `onInvalidateOperations` - Fires when operations are invalidated (e.g. by file watchers).
- * - `onGraphStateChanged` - Fires on any observable graph state change.
- *
- * @alpha
- */
-export declare class OperationGraphHooks {
-    /**
-     * Hook invoked to decide what work a potential new iteration contains.
-     * Use the `lastExecutedRecords` to determine which operations are new or have had their inputs changed.
-     * Set the `enabled` states on the values in `initialRecords` to control which operations will be executed.
-     *
-     * @remarks
-     * This hook is synchronous to guarantee that the `lastExecutedRecords` map remains stable for the
-     * duration of configuration. This hook often executes while an execution iteration is currently running, so
-     * operations could complete if there were async ticks during the configuration phase.
-     *
-     * If no operations are marked for execution, the iteration will not be scheduled.
-     * If there is an existing scheduled iteration, it will remain.
-     */
-    readonly configureIteration: SyncHook<[
-        ReadonlyMap<Operation, IConfigurableOperation>,
-        ReadonlyMap<Operation, IOperationExecutionResult>,
-        IOperationGraphIterationOptions
-    ]>;
-    /**
-     * Hook invoked before operation start for an iteration. Allows a plugin to perform side-effects or
-     * short-circuit the entire iteration.
-     *
-     * If any tap returns an {@link OperationStatus}, the remaining taps are skipped and the iteration will
-     * end immediately with that status. All operations which have not yet executed will be marked
-     * Aborted.
-     */
-    readonly beforeExecuteIterationAsync: AsyncSeriesBailHook<[
-        ReadonlyMap<Operation, IOperationExecutionResult>,
-        IOperationGraphIterationOptions
-    ], OperationStatus | undefined | void>;
-    /**
-     * Batched hook invoked when one or more operation statuses have changed during the same microtask.
-     * The hook receives an array of the operation execution results that changed status.
-     * @remarks
-     * This hook is batched to reduce noise when updating many operations synchronously in quick succession.
-     */
-    readonly onExecutionStatesUpdated: SyncHook<[ReadonlySet<IOperationExecutionResult>]>;
-    /**
-     * Hook invoked when one or more operations have their enabled state mutated via
-     * {@link IOperationGraph.setEnabledStates}. Provides the set of operations whose
-     * enabled state actually changed.
-     */
-    readonly onEnableStatesChanged: SyncHook<[ReadonlySet<Operation>]>;
-    /**
-     * Hook invoked immediately after a new execution iteration is scheduled (i.e. operations selected and prepared),
-     * before any operations in that iteration have started executing. Can be used to snapshot planned work,
-     * drive UIs, or pre-compute auxiliary data.
-     */
-    readonly onIterationScheduled: SyncHook<[ReadonlyMap<Operation, IOperationExecutionResult>]>;
-    /**
-     * Hook invoked when any observable state on the operation graph changes.
-     * This includes configuration mutations (parallelism, quiet/debug modes, pauseNextIteration)
-     * as well as dynamic state (status transitions, scheduled iteration availability, etc.).
-     * Hook is series for stable output.
-     */
-    readonly onGraphStateChanged: SyncHook<[IOperationGraph]>;
-    /**
-     * Hook invoked when operations are invalidated for any reason.
-     */
-    readonly onInvalidateOperations: SyncHook<[Iterable<Operation>, string | undefined]>;
-    /**
-     * Hook invoked after an iteration has finished and the command is watching for changes.
-     * May be used to display additional relevant data to the user.
-     * Only relevant when running in watch mode.
-     */
-    readonly onIdle: SyncHook<void>;
-    /**
-     * Hook invoked after executing a set of operations.
-     * Hook is series for stable output.
-     */
-    readonly afterExecuteIterationAsync: AsyncSeriesWaterfallHook<[
-        OperationStatus,
-        ReadonlyMap<Operation, IOperationExecutionResult>,
-        IOperationGraphIterationOptions
-    ]>;
-    /**
-     * Hook invoked after executing an iteration, before the telemetry entry is written.
-     * Allows the caller to augment or modify the log entry.
-     */
-    readonly beforeLog: SyncHook<ITelemetryData, void>;
-    /**
-     * Hook invoked before executing a operation.
-     */
-    readonly beforeExecuteOperationAsync: AsyncSeriesBailHook<[
-        IOperationRunnerContext & IOperationExecutionResult
-    ], OperationStatus | undefined>;
-    /**
-     * Hook invoked to define environment variables for an operation.
-     * May be invoked by the runner to get the environment for the operation.
-     */
-    readonly createEnvironmentForOperation: SyncWaterfallHook<[
-        IEnvironment,
-        IOperationRunnerContext & IOperationExecutionResult
-    ]>;
-    /**
-     * Hook invoked after executing a operation.
-     */
-    readonly afterExecuteOperationAsync: AsyncSeriesHook<[
-        IOperationRunnerContext & IOperationExecutionResult
-    ]>;
-}
-//# sourceMappingURL=OperationGraphHooks.d.ts.map