@rushstack/rush-sdk 5.90.2 → 5.92.0

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

@@ -0,0 +1,80 @@
+import { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import { IPhase } from '../../api/CommandLineConfiguration';
+import { IOperationRunner } from './IOperationRunner';
+/**
+ * Options for constructing a new Operation.
+ * @alpha
+ */
+export interface IOperationOptions {
+    /**
+     * The Rush phase associated with this Operation, if any
+     */
+    phase?: IPhase | undefined;
+    /**
+     * The Rush project associated with this Operation, if any
+     */
+    project?: RushConfigurationProject | undefined;
+    /**
+     * When the scheduler is ready to process this `Operation`, the `runner` implements the actual work of
+     * running the operation.
+     */
+    runner?: IOperationRunner | undefined;
+}
+/**
+ * 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 of running a single operation.
+ *
+ * The graph of `Operation` instances will be cloned into a separate execution graph after processing.
+ *
+ * @alpha
+ */
+export declare class Operation {
+    /**
+     * The Rush phase associated with this Operation, if any
+     */
+    readonly associatedPhase: IPhase | undefined;
+    /**
+     * The Rush project associated with this Operation, if any
+     */
+    readonly associatedProject: RushConfigurationProject | undefined;
+    /**
+     * A set of all operations which depend on this operation.
+     */
+    readonly consumers: ReadonlySet<Operation>;
+    /**
+     * A set of all dependencies which must be executed before this operation is complete.
+     */
+    readonly dependencies: ReadonlySet<Operation>;
+    /**
+     * When the scheduler is ready to process this `Operation`, the `runner` implements the actual work of
+     * running the operation.
+     */
+    runner: IOperationRunner | undefined;
+    /**
+     * The weight for this operation. This scalar is the contribution of this operation to the
+     * `criticalPathLength` calculation above. Modify to indicate the following:
+     * - `weight` === 1: indicates that this operation has an average duration
+     * - `weight` &gt; 1: indicates that this operation takes longer than average and so the scheduler
+     *     should try to favor starting it over other, shorter operations. An example might be an operation that
+     *     bundles an entire application and runs whole-program optimization.
+     * - `weight` &lt; 1: indicates that this operation takes less time than average and so the scheduler
+     *     should favor other, longer operations over it. An example might be an operation to unpack a cached
+     *     output, or an operation using NullOperationRunner, which might use a value of 0.
+     */
+    weight: number;
+    constructor(options?: IOperationOptions);
+    /**
+     * The name of this operation, for logging.
+     */
+    get name(): string | undefined;
+    /**
+     * Adds the specified operation as a dependency and updates the consumer list.
+     */
+    addDependency(dependency: Operation): void;
+    /**
+     * Deletes the specified operation as a dependency and updates the consumer list.
+     */
+    deleteDependency(dependency: Operation): void;
+}
+//# sourceMappingURL=Operation.d.ts.map

package/lib/logic/operations/Operation.js

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

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

@@ -0,0 +1,11 @@
+/**
+ * Encapsulates information about an error
+ * @alpha
+ */
+export declare class OperationError extends Error {
+    protected _type: string;
+    constructor(type: string, message: string);
+    get message(): string;
+    toString(): string;
+}
+//# sourceMappingURL=OperationError.d.ts.map

package/lib/logic/operations/OperationError.js

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

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

@@ -0,0 +1,42 @@
+import { TerminalWritable } from '@rushstack/terminal';
+import { Operation } from './Operation';
+import { IExecutionResult } from './IOperationExecutionResult';
+export interface IOperationExecutionManagerOptions {
+    quietMode: boolean;
+    debugMode: boolean;
+    parallelism: number;
+    changedProjectsOnly: boolean;
+    destination?: TerminalWritable;
+}
+/**
+ * A class which manages the execution of a set of tasks with interdependencies.
+ * Initially, and at the end of each task execution, all unblocked tasks
+ * are added to a ready queue which is then executed. This is done continually until all
+ * tasks are complete, or prematurely fails if any of the tasks fail.
+ */
+export declare class OperationExecutionManager {
+    private readonly _changedProjectsOnly;
+    private readonly _executionRecords;
+    private readonly _quietMode;
+    private readonly _parallelism;
+    private readonly _totalOperations;
+    private readonly _outputWritable;
+    private readonly _colorsNewlinesTransform;
+    private readonly _streamCollator;
+    private readonly _terminal;
+    private _hasAnyFailures;
+    private _hasAnyNonAllowedWarnings;
+    private _completedOperations;
+    constructor(operations: Set<Operation>, options: IOperationExecutionManagerOptions);
+    private _streamCollator_onWriterActive;
+    /**
+     * Executes all operations which have been registered, returning a promise which is resolved when all the
+     * operations are completed successfully, or rejects when any operation fails.
+     */
+    executeAsync(): Promise<IExecutionResult>;
+    /**
+     * Handles the result of the operation and propagates any relevant effects.
+     */
+    private _onOperationComplete;
+}
+//# sourceMappingURL=OperationExecutionManager.d.ts.map

package/lib/logic/operations/OperationExecutionManager.js

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

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

@@ -0,0 +1,82 @@
+import { StdioSummarizer } from '@rushstack/terminal';
+import { CollatedWriter, StreamCollator } from '@rushstack/stream-collator';
+import { OperationStatus } from './OperationStatus';
+import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
+import { Operation } from './Operation';
+import { Stopwatch } from '../../utilities/Stopwatch';
+import { OperationMetadataManager } from './OperationMetadataManager';
+export interface IOperationExecutionRecordContext {
+    streamCollator: StreamCollator;
+    debugMode: boolean;
+    quietMode: boolean;
+}
+/**
+ * Internal class representing everything about executing an operation
+ */
+export declare class OperationExecutionRecord implements IOperationRunnerContext {
+    /**
+     * 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'.
+     */
+    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).
+     */
+    error: Error | undefined;
+    /**
+     * This number represents how far away this Operation is from the furthest "root" operation (i.e.
+     * an operation with no consumers). This helps us to calculate the critical path (i.e. the
+     * longest chain of projects which must be executed in order, thereby limiting execution speed
+     * of the entire operation tree.
+     *
+     * This number is calculated via a memoized depth-first search, and when choosing the next
+     * operation to execute, the operation with the highest criticalPathLength is chosen.
+     *
+     * Example:
+     *        (0) A
+     *             \
+     *          (1) B     C (0)         (applications)
+     *               \   /|\
+     *                \ / | \
+     *             (2) D  |  X (1)      (utilities)
+     *                    | / \
+     *                    |/   \
+     *                (2) Y     Z (2)   (other utilities)
+     *
+     * All roots (A & C) have a criticalPathLength of 0.
+     * B has a score of 1, since A depends on it.
+     * D has a score of 2, since we look at the longest chain (e.g D->B->A is longer than D->C)
+     * X has a score of 1, since the only package which depends on it is A
+     * Z has a score of 2, since only X depends on it, and X has a score of 1
+     * Y has a score of 2, since the chain Y->X->C is longer than Y->C
+     *
+     * The algorithm is implemented in AsyncOperationQueue.ts as calculateCriticalPathLength()
+     */
+    criticalPathLength: number | undefined;
+    /**
+     * The set of operations that must complete before this operation executes.
+     */
+    readonly dependencies: Set<OperationExecutionRecord>;
+    /**
+     * The set of operations that depend on this operation.
+     */
+    readonly consumers: Set<OperationExecutionRecord>;
+    readonly stopwatch: Stopwatch;
+    readonly stdioSummarizer: StdioSummarizer;
+    readonly runner: IOperationRunner;
+    readonly weight: number;
+    readonly _operationMetadataManager: OperationMetadataManager | undefined;
+    private readonly _context;
+    private _collatedWriter;
+    constructor(operation: Operation, context: IOperationExecutionRecordContext);
+    get name(): string;
+    get debugMode(): boolean;
+    get quietMode(): boolean;
+    get collatedWriter(): CollatedWriter;
+    get nonCachedDurationMs(): number | undefined;
+    executeAsync(onResult: (record: OperationExecutionRecord) => void): Promise<void>;
+}
+//# sourceMappingURL=OperationExecutionRecord.d.ts.map

package/lib/logic/operations/OperationExecutionRecord.js

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

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

@@ -0,0 +1,48 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { OperationStateFile } from './OperationStateFile';
+import type { IPhase } from '../../api/CommandLineConfiguration';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+/**
+ * @internal
+ */
+export interface IOperationMetadataManagerOptions {
+    rushProject: RushConfigurationProject;
+    phase: IPhase;
+}
+/**
+ * @internal
+ */
+export interface IOperationMetaData {
+    durationInSeconds: number;
+    logPath: string;
+    errorLogPath: string;
+}
+/**
+ * A helper class for managing the meta files of a operation.
+ *
+ * @internal
+ */
+export declare class OperationMetadataManager {
+    readonly stateFile: OperationStateFile;
+    private _metadataFolder;
+    private _logPath;
+    private _errorLogPath;
+    private _relativeLogPath;
+    private _relativeErrorLogPath;
+    constructor(options: IOperationMetadataManagerOptions);
+    /**
+     * Returns the relative paths of the metadata files to project folder.
+     *
+     * Example: `.rush/temp/operation/_phase_build/state.json`
+     * Example: `.rush/temp/operation/_phase_build/all.log`
+     * Example: `.rush/temp/operation/_phase_build/error.log`
+     */
+    get relativeFilepaths(): string[];
+    saveAsync({ durationInSeconds, logPath, errorLogPath }: IOperationMetaData): Promise<void>;
+    tryRestoreAsync({ terminal, logPath, errorLogPath }: {
+        terminal: ITerminal;
+        logPath: string;
+        errorLogPath: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=OperationMetadataManager.d.ts.map

package/lib/logic/operations/OperationMetadataManager.js

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

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

@@ -0,0 +1,17 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+import { IExecutionResult } from './IOperationExecutionResult';
+/**
+ * Phased command plugin that emits a summary of build results to the console.
+ */
+export declare class OperationResultSummarizerPlugin implements IPhasedCommandPlugin {
+    private readonly _terminal;
+    constructor(terminal: ITerminal);
+    apply(hooks: PhasedCommandHooks): void;
+}
+/**
+ * Prints out a report of the status of each project
+ * @internal
+ */
+export declare function _printOperationStatus(terminal: ITerminal, result: IExecutionResult): void;
+//# sourceMappingURL=OperationResultSummarizerPlugin.d.ts.map

package/lib/logic/operations/OperationResultSummarizerPlugin.js

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

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

@@ -0,0 +1,39 @@
+/**
+ * @internal
+ */
+export interface IOperationStateFileOptions {
+    projectFolder: string;
+    metadataFolder: string;
+}
+/**
+ * @internal
+ */
+export interface IOperationStateJson {
+    nonCachedDurationMs: number;
+}
+/**
+ * A helper class for managing the state file of a operation.
+ *
+ * @internal
+ */
+export declare class OperationStateFile {
+    private _state;
+    /**
+     * The path of the state json file.
+     *
+     * Example: `/code/repo/my-project/.rush/temp/operation/_phase_build/state.json`
+     */
+    readonly filepath: string;
+    /**
+     * The relative path of the state json file to project folder
+     *
+     * Example: `.rush/temp/operation/_phase_build/state.json`
+     */
+    readonly relativeFilepath: string;
+    static filename: string;
+    constructor(options: IOperationStateFileOptions);
+    get state(): IOperationStateJson | undefined;
+    writeAsync(json: IOperationStateJson): Promise<void>;
+    tryRestoreAsync(): Promise<IOperationStateJson | undefined>;
+}
+//# sourceMappingURL=OperationStateFile.d.ts.map

package/lib/logic/operations/OperationStateFile.js

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

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

@@ -0,0 +1,43 @@
+/**
+ * Enumeration defining potential states of an operation
+ * @beta
+ */
+export declare enum OperationStatus {
+    /**
+     * The Operation is on the queue, ready to execute (but may be waiting for dependencies)
+     */
+    Ready = "READY",
+    /**
+     * The Operation is currently executing
+     */
+    Executing = "EXECUTING",
+    /**
+     * The Operation completed successfully and did not write to standard output
+     */
+    Success = "SUCCESS",
+    /**
+     * The Operation completed successfully, but wrote to standard output
+     */
+    SuccessWithWarning = "SUCCESS WITH WARNINGS",
+    /**
+     * The Operation was skipped via the legacy incremental build logic
+     */
+    Skipped = "SKIPPED",
+    /**
+     * The Operation had its outputs restored from the build cache
+     */
+    FromCache = "FROM CACHE",
+    /**
+     * The Operation failed
+     */
+    Failure = "FAILURE",
+    /**
+     * The Operation could not be executed because one or more of its dependencies failed
+     */
+    Blocked = "BLOCKED",
+    /**
+     * The Operation was a no-op (for example, it had an empty script)
+     */
+    NoOp = "NO OP"
+}
+//# sourceMappingURL=OperationStatus.d.ts.map

package/lib/logic/operations/OperationStatus.js

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

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

@@ -0,0 +1,9 @@
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+/**
+ * Core phased command plugin that provides the functionality for generating a base operation graph
+ * from the set of selected projects and phases.
+ */
+export declare class PhasedOperationPlugin implements IPhasedCommandPlugin {
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=PhasedOperationPlugin.d.ts.map

package/lib/logic/operations/PhasedOperationPlugin.js

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

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

@@ -0,0 +1,17 @@
+import { TerminalWritable, ITerminalChunk } from '@rushstack/terminal';
+import { CollatedTerminal } from '@rushstack/stream-collator';
+import { RushConfigurationProject } from '../../api/RushConfigurationProject';
+export declare class ProjectLogWritable extends TerminalWritable {
+    private readonly _project;
+    private readonly _terminal;
+    readonly logPath: string;
+    readonly errorLogPath: string;
+    readonly relativeLogPath: string;
+    readonly relativeErrorLogPath: string;
+    private _logWriter;
+    private _errorLogWriter;
+    constructor(project: RushConfigurationProject, terminal: CollatedTerminal, logFilenameIdentifier: string);
+    protected onWriteChunk(chunk: ITerminalChunk): void;
+    protected onClose(): void;
+}
+//# sourceMappingURL=ProjectLogWritable.d.ts.map

package/lib/logic/operations/ProjectLogWritable.js

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

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

@@ -0,0 +1,87 @@
+import { OperationStatus } from './OperationStatus';
+import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
+import type { RushConfiguration } from '../../api/RushConfiguration';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import type { ProjectChangeAnalyzer } from '../ProjectChangeAnalyzer';
+import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
+import type { IPhase } from '../../api/CommandLineConfiguration';
+export interface IProjectDeps {
+    files: {
+        [filePath: string]: string;
+    };
+    arguments: string;
+}
+export interface IOperationRunnerOptions {
+    rushProject: RushConfigurationProject;
+    rushConfiguration: RushConfiguration;
+    buildCacheConfiguration: BuildCacheConfiguration | undefined;
+    commandToRun: string;
+    isIncrementalBuildAllowed: boolean;
+    projectChangeAnalyzer: ProjectChangeAnalyzer;
+    displayName: string;
+    phase: IPhase;
+    /**
+     * The set of phases being executed in the current command, for validation of rush-project.json
+     */
+    selectedPhases: Iterable<IPhase>;
+}
+/**
+ * An `IOperationRunner` subclass that performs an operation via a shell command.
+ * Currently contains the build cache logic, pending extraction as separate operations.
+ * Supports skipping an operation if allowed and it is already up-to-date.
+ */
+export declare class ShellOperationRunner implements IOperationRunner {
+    readonly name: string;
+    isCacheWriteAllowed: boolean;
+    isSkipAllowed: boolean;
+    readonly reportTiming: boolean;
+    readonly silent: boolean;
+    readonly warningsAreAllowed: boolean;
+    private readonly _rushProject;
+    private readonly _phase;
+    private readonly _rushConfiguration;
+    private readonly _buildCacheConfiguration;
+    private readonly _commandName;
+    private readonly _commandToRun;
+    private readonly _isCacheReadAllowed;
+    private readonly _projectChangeAnalyzer;
+    private readonly _packageDepsFilename;
+    private readonly _logFilenameIdentifier;
+    private readonly _selectedPhases;
+    /**
+     * UNINITIALIZED === we haven't tried to initialize yet
+     * undefined === we didn't create one because the feature is not enabled
+     */
+    private _projectBuildCache;
+    constructor(options: IOperationRunnerOptions);
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
+    private _executeAsync;
+    private _tryGetProjectBuildCacheAsync;
+}
+/**
+ * When running a command from the "scripts" block in package.json, if the command
+ * contains Unix-style path slashes and the OS is Windows, the package managers will
+ * convert slashes to backslashes.  This is a complicated undertaking.  For example, they
+ * need to convert "node_modules/bin/this && ./scripts/that --name keep/this"
+ * to "node_modules\bin\this && .\scripts\that --name keep/this", and they don't want to
+ * convert ANY of the slashes in "cmd.exe /c echo a/b".  NPM and PNPM use npm-lifecycle for this,
+ * but it unfortunately has a dependency on the entire node-gyp kitchen sink.  Yarn has a
+ * simplified implementation in fix-cmd-win-slashes.js, but it's not exposed as a library.
+ *
+ * Fundamentally NPM's whole feature seems misguided:  They start by inviting people to write
+ * shell scripts that will be executed by wildly different shell languages (e.g. cmd.exe and Bash).
+ * It's very tricky for a developer to guess what's safe to do without testing every OS.
+ * Even simple path separators are not portable, so NPM added heuristics to figure out which
+ * slashes are part of a path or not, and convert them.  These workarounds end up having tons
+ * of special cases.  They probably could have implemented their own entire minimal cross-platform
+ * shell language with less code and less confusion than npm-lifecycle's approach.
+ *
+ * We've deprecated shell operators inside package.json.  Instead, we advise people to move their
+ * scripts into conventional script files, and put only a file path in package.json.  So, for
+ * Rush's workaround here, we really only care about supporting the small set of cases seen in the
+ * unit tests.  For anything that doesn't fit those patterns, we leave the string untouched
+ * (i.e. err on the side of not breaking anything).  We could revisit this later if someone
+ * complains about it, but so far nobody has.  :-)
+ */
+export declare function convertSlashesForWindows(command: string): string;
+//# sourceMappingURL=ShellOperationRunner.d.ts.map

package/lib/logic/operations/ShellOperationRunner.js

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

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

@@ -0,0 +1,8 @@
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+/**
+ * Core phased command plugin that provides the functionality for executing an operation via shell command.
+ */
+export declare class ShellOperationRunnerPlugin implements IPhasedCommandPlugin {
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=ShellOperationRunnerPlugin.d.ts.map

package/lib/logic/operations/ShellOperationRunnerPlugin.js

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

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

@@ -0,0 +1,54 @@
+import type { LogBase } from '@pnpm/logger';
+import type { IPackageJson } from '@rushstack/node-core-library';
+import type { IPnpmShrinkwrapYaml } from './PnpmShrinkwrapFile';
+/**
+ * The `settings` parameter passed to {@link IPnpmfileShim.hooks.readPackage} and
+ * {@link IPnpmfileShim.hooks.afterAllResolved}.
+ */
+export interface IPnpmfileShimSettings {
+    semverPath: string;
+    allPreferredVersions: {
+        [dependencyName: string]: string;
+    };
+    allowedAlternativeVersions: {
+        [dependencyName: string]: ReadonlyArray<string>;
+    };
+    /**
+     * The versions of all packages that are part of the workspace.
+     */
+    workspaceVersions: Record<string, string>;
+    userPnpmfilePath?: string;
+}
+/**
+ * The `context` parameter passed to {@link IPnpmfile.hooks.readPackage}, as defined by the
+ * pnpmfile API contract.
+ */
+export interface IPnpmfileContext {
+    log: (message: string) => void;
+    pnpmfileShimSettings?: IPnpmfileShimSettings;
+}
+/**
+ * The `log` parameter passed to {@link IPnpmfile.hooks.filterLog}.
+ */
+export declare type IPnpmLog = LogBase & {
+    [key: string]: unknown;
+};
+/**
+ * The 'hooks' property of the pnpmfile
+ */
+export interface IPnpmfileHooks {
+    afterAllResolved?: (lockfile: IPnpmShrinkwrapYaml, context: IPnpmfileContext) => IPnpmShrinkwrapYaml;
+    readPackage?: (pkg: IPackageJson, context: IPnpmfileContext) => IPackageJson;
+    /**
+     * @remarks
+     * This function is not supported by PNPM versions before 6.17.0.
+     */
+    filterLog?: (log: IPnpmLog) => boolean;
+}
+/**
+ * The pnpmfile, as defined by the pnpmfile API contract.
+ */
+export interface IPnpmfile {
+    hooks?: IPnpmfileHooks;
+}
+//# sourceMappingURL=IPnpmfile.d.ts.map

package/lib/logic/pnpm/IPnpmfile.js

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