@rushstack/rush-sdk 5.100.2 → 5.101.0-pr3949.3

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

@@ -35,6 +35,33 @@ export interface IOperationRunnerContext {
      * Object used to track elapsed time.
      */
     stopwatch: IStopwatchResult;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * The set of operations that depend on this operation.
+     */
+    readonly consumers: Set<IOperationRunnerContext>;
+    /**
+     * The operation runner that is executing this operation.
+     */
+    readonly runner: IOperationRunner;
+    /**
+     * Normally the incremental build logic will rebuild changed projects as well as
+     * any projects that directly or indirectly depend on a changed project.
+     * If true, then the incremental build logic will only rebuild changed projects and
+     * ignore dependent projects.
+     */
+    readonly changedProjectsOnly: boolean;
 }
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
@@ -48,10 +75,6 @@ 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.
      */
@@ -65,10 +88,6 @@ export interface IOperationRunner {
      * 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.
      */

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

@@ -8,6 +8,8 @@ export interface IOperationExecutionManagerOptions {
     parallelism: number;
     changedProjectsOnly: boolean;
     destination?: TerminalWritable;
+    beforeExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
+    afterExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     beforeExecuteOperations?: (records: Map<Operation, OperationExecutionRecord>) => Promise<void>;
 }
@@ -27,11 +29,14 @@ export declare class OperationExecutionManager {
     private readonly _colorsNewlinesTransform;
     private readonly _streamCollator;
     private readonly _terminal;
+    private readonly _beforeExecuteOperation?;
+    private readonly _afterExecuteOperation?;
     private readonly _onOperationStatusChanged?;
     private readonly _beforeExecuteOperations?;
     private _hasAnyFailures;
     private _hasAnyNonAllowedWarnings;
     private _completedOperations;
+    private _executionQueue;
     constructor(operations: Set<Operation>, options: IOperationExecutionManagerOptions);
     private _streamCollator_onWriterActive;
     /**

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

@@ -10,9 +10,12 @@ export interface IOperationExecutionRecordContext {
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     debugMode: boolean;
     quietMode: boolean;
+    changedProjectsOnly: boolean;
 }
 /**
  * Internal class representing everything about executing an operation
+ *
+ * @internal
  */
 export declare class OperationExecutionRecord implements IOperationRunnerContext {
     /**
@@ -37,6 +40,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * operation to execute, the operation with the highest criticalPathLength is chosen.
      *
      * Example:
+     * ```
      *        (0) A
      *             \
      *          (1) B     C (0)         (applications)
@@ -53,6 +57,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * 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()
      */
@@ -76,8 +81,10 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     get name(): string;
     get debugMode(): boolean;
     get quietMode(): boolean;
+    get changedProjectsOnly(): boolean;
     get collatedWriter(): CollatedWriter;
     get nonCachedDurationMs(): number | undefined;
-    executeAsync(onResult: (record: OperationExecutionRecord) => void): Promise<void>;
+    get cobuildRunnerId(): string | undefined;
+    executeAsync(onResult: (record: OperationExecutionRecord) => Promise<void>): Promise<void>;
 }
 //# sourceMappingURL=OperationExecutionRecord.d.ts.map

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

@@ -16,6 +16,8 @@ export interface IOperationMetaData {
     durationInSeconds: number;
     logPath: string;
     errorLogPath: string;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 /**
  * A helper class for managing the meta files of a operation.
@@ -38,7 +40,7 @@ export declare class OperationMetadataManager {
      * Example: `.rush/temp/operation/_phase_build/error.log`
      */
     get relativeFilepaths(): string[];
-    saveAsync({ durationInSeconds, logPath, errorLogPath }: IOperationMetaData): Promise<void>;
+    saveAsync({ durationInSeconds, cobuildContextId, cobuildRunnerId, logPath, errorLogPath }: IOperationMetaData): Promise<void>;
     tryRestoreAsync({ terminal, logPath, errorLogPath }: {
         terminal: ITerminal;
         logPath: string;

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

@@ -0,0 +1,52 @@
+import { AsyncSeriesBailHook, AsyncSeriesWaterfallHook } from 'tapable';
+import type { ITerminal } from '@rushstack/node-core-library';
+import type { IOperationRunnerContext } from './IOperationRunner';
+import type { OperationStatus } from './OperationStatus';
+import type { IProjectDeps, ShellOperationRunner } from './ShellOperationRunner';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import type { IPhase } from '../../api/CommandLineConfiguration';
+/**
+ * A plugin tht interacts with a operation runner
+ */
+export interface IOperationRunnerPlugin {
+    /**
+     * Applies this plugin.
+     */
+    apply(hooks: OperationRunnerHooks): void;
+}
+export interface IOperationRunnerBeforeExecuteContext {
+    context: IOperationRunnerContext;
+    runner: ShellOperationRunner;
+    terminal: ITerminal;
+    projectDeps: IProjectDeps | undefined;
+    lastProjectDeps: IProjectDeps | undefined;
+    trackedProjectFiles: string[] | undefined;
+    logPath: string;
+    errorLogPath: string;
+    rushProject: RushConfigurationProject;
+    phase: IPhase;
+    commandName: string;
+    commandToRun: string;
+    finallyCallbacks: (() => void)[];
+}
+export interface IOperationRunnerAfterExecuteContext {
+    context: IOperationRunnerContext;
+    terminal: ITerminal;
+    /**
+     * Exit code of the operation command
+     */
+    exitCode: number;
+    status: OperationStatus;
+    taskIsSuccessful: boolean;
+    logPath: string;
+    errorLogPath: string;
+}
+/**
+ * Hooks into the lifecycle of the operation runner
+ *
+ */
+export declare class OperationRunnerHooks {
+    beforeExecute: AsyncSeriesBailHook<IOperationRunnerBeforeExecuteContext, OperationStatus | undefined>;
+    afterExecute: AsyncSeriesWaterfallHook<IOperationRunnerAfterExecuteContext>;
+}
+//# sourceMappingURL=OperationRunnerHooks.d.ts.map

package/lib/logic/operations/OperationRunnerHooks.js

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

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

@@ -10,6 +10,8 @@ export interface IOperationStateFileOptions {
  */
 export interface IOperationStateJson {
     nonCachedDurationMs: number;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 /**
  * A helper class for managing the state file of a operation.

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

@@ -7,10 +7,18 @@ export declare enum OperationStatus {
      * The Operation is on the queue, ready to execute (but may be waiting for dependencies)
      */
     Ready = "READY",
+    /**
+     * The Operation is Queued
+     */
+    Queued = "QUEUED",
     /**
      * The Operation is currently executing
      */
     Executing = "EXECUTING",
+    /**
+     * The Operation is currently executing by a remote process
+     */
+    RemoteExecuting = "REMOTE EXECUTING",
     /**
      * The Operation completed successfully and did not write to standard output
      */

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

@@ -0,0 +1,20 @@
+export type ICallbackFn = () => Promise<void> | void;
+export interface IPeriodicCallbackOptions {
+    interval: number;
+}
+/**
+ * A help class to run callbacks in a loop with a specified interval.
+ *
+ * @beta
+ */
+export declare class PeriodicCallback {
+    private _callbacks;
+    private _interval;
+    private _intervalId;
+    private _isRunning;
+    constructor(options: IPeriodicCallbackOptions);
+    addCallback(callback: ICallbackFn): void;
+    start(): void;
+    stop(): void;
+}
+//# sourceMappingURL=PeriodicCallback.d.ts.map

package/lib/logic/operations/PeriodicCallback.js

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

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

@@ -1,9 +1,10 @@
 import { OperationStatus } from './OperationStatus';
 import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
+import { PeriodicCallback } from './PeriodicCallback';
+import { OperationRunnerHooks } from './OperationRunnerHooks';
 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: {
@@ -14,9 +15,7 @@ export interface IProjectDeps {
 export interface IOperationRunnerOptions {
     rushProject: RushConfigurationProject;
     rushConfiguration: RushConfiguration;
-    buildCacheConfiguration: BuildCacheConfiguration | undefined;
     commandToRun: string;
-    isIncrementalBuildAllowed: boolean;
     projectChangeAnalyzer: ProjectChangeAnalyzer;
     displayName: string;
     phase: IPhase;
@@ -32,31 +31,24 @@ export interface IOperationRunnerOptions {
  */
 export declare class ShellOperationRunner implements IOperationRunner {
     readonly name: string;
-    isCacheWriteAllowed: boolean;
-    isSkipAllowed: boolean;
     readonly reportTiming: boolean;
     readonly silent: boolean;
     readonly warningsAreAllowed: boolean;
+    readonly hooks: OperationRunnerHooks;
+    readonly periodicCallback: PeriodicCallback;
+    readonly logFilenameIdentifier: string;
+    static readonly periodicCallbackIntervalInSeconds: number;
     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

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

@@ -94,6 +94,10 @@ export interface IPnpmShrinkwrapYaml {
     registry: string;
     /** The list of specifiers used to resolve direct dependency versions */
     specifiers: Record<string, string>;
+    /** The list of override version number for dependencies */
+    overrides?: {
+        [dependency: string]: string;
+    };
 }
 /**
  * Given an encoded "dependency key" from the PNPM shrinkwrap file, this parses it into an equivalent
@@ -111,6 +115,7 @@ export declare class PnpmShrinkwrapFile extends BaseShrinkwrapFile {
     readonly importers: ReadonlyMap<string, IPnpmShrinkwrapImporterYaml>;
     readonly specifiers: ReadonlyMap<string, string>;
     readonly packages: ReadonlyMap<string, IPnpmShrinkwrapDependencyYaml>;
+    readonly overrides: ReadonlyMap<string, string>;
     private readonly _shrinkwrapJson;
     private readonly _integrities;
     private _pnpmfileConfiguration;

package/lib/pluginFramework/PhasedCommandHooks.d.ts

@@ -6,8 +6,10 @@ import type { RushConfiguration } from '../api/RushConfiguration';
 import type { RushConfigurationProject } from '../api/RushConfigurationProject';
 import type { Operation } from '../logic/operations/Operation';
 import type { ProjectChangeAnalyzer } from '../logic/ProjectChangeAnalyzer';
-import { ITelemetryData } from '../logic/Telemetry';
-import { IExecutionResult, IOperationExecutionResult } from '../logic/operations/IOperationExecutionResult';
+import type { IExecutionResult, IOperationExecutionResult } from '../logic/operations/IOperationExecutionResult';
+import type { CobuildConfiguration } from '../api/CobuildConfiguration';
+import type { IOperationRunnerContext } from '../logic/operations/IOperationRunner';
+import type { ITelemetryData } from '../logic/Telemetry';
 /**
  * A plugin that interacts with a phased commands.
  * @alpha
@@ -27,6 +29,10 @@ export interface ICreateOperationsContext {
      * The configuration for the build cache, if the feature is enabled.
      */
     readonly buildCacheConfiguration: BuildCacheConfiguration | undefined;
+    /**
+     * The configuration for the cobuild, if cobuild feature and build cache feature are both enabled.
+     */
+    readonly cobuildConfiguration: CobuildConfiguration | undefined;
     /**
      * The set of custom parameters for the executing command.
      * Maps from the `longName` field in command-line.json to the parser configuration in ts-command-line.
@@ -86,7 +92,10 @@ export declare class PhasedCommandHooks {
      * Hook invoked before operation start
      * Hook is series for stable output.
      */
-    readonly beforeExecuteOperations: AsyncSeriesHook<[Map<Operation, IOperationExecutionResult>]>;
+    readonly beforeExecuteOperations: AsyncSeriesHook<[
+        Map<Operation, IOperationExecutionResult>,
+        ICreateOperationsContext
+    ]>;
     /**
      * Hook invoked when operation status changed
      * Hook is series for stable output.
@@ -98,6 +107,14 @@ export declare class PhasedCommandHooks {
      * Hook is series for stable output.
      */
     readonly afterExecuteOperations: AsyncSeriesHook<[IExecutionResult, ICreateOperationsContext]>;
+    /**
+     * Hook invoked before executing a operation.
+     */
+    readonly beforeExecuteOperation: AsyncSeriesHook<[IOperationRunnerContext]>;
+    /**
+     * Hook invoked after executing a operation.
+     */
+    readonly afterExecuteOperation: AsyncSeriesHook<[IOperationRunnerContext]>;
     /**
      * Hook invoked after a run has finished and the command is watching for changes.
      * May be used to display additional relevant data to the user.

package/lib/pluginFramework/RushSession.d.ts

@@ -1,8 +1,10 @@
 import { ITerminalProvider } from '@rushstack/node-core-library';
-import { IBuildCacheJson } from '../api/BuildCacheConfiguration';
-import { ICloudBuildCacheProvider } from '../logic/buildCache/ICloudBuildCacheProvider';
 import { ILogger } from './logging/Logger';
 import { RushLifecycleHooks } from './RushLifeCycle';
+import type { IBuildCacheJson } from '../api/BuildCacheConfiguration';
+import type { ICloudBuildCacheProvider } from '../logic/buildCache/ICloudBuildCacheProvider';
+import type { ICobuildJson } from '../api/CobuildConfiguration';
+import type { ICobuildLockProvider } from '../logic/cobuild/ICobuildLockProvider';
 /**
  * @beta
  */
@@ -14,17 +16,24 @@ export interface IRushSessionOptions {
  * @beta
  */
 export type CloudBuildCacheProviderFactory = (buildCacheJson: IBuildCacheJson) => ICloudBuildCacheProvider | Promise<ICloudBuildCacheProvider>;
+/**
+ * @beta
+ */
+export type CobuildLockProviderFactory = (cobuildJson: ICobuildJson) => ICobuildLockProvider | Promise<ICobuildLockProvider>;
 /**
  * @beta
  */
 export declare class RushSession {
     private readonly _options;
     private readonly _cloudBuildCacheProviderFactories;
+    private readonly _cobuildLockProviderFactories;
     readonly hooks: RushLifecycleHooks;
     constructor(options: IRushSessionOptions);
     getLogger(name: string): ILogger;
     get terminalProvider(): ITerminalProvider;
     registerCloudBuildCacheProviderFactory(cacheProviderName: string, factory: CloudBuildCacheProviderFactory): void;
     getCloudBuildCacheProviderFactory(cacheProviderName: string): CloudBuildCacheProviderFactory | undefined;
+    registerCobuildLockProviderFactory(cobuildLockProviderName: string, factory: CobuildLockProviderFactory): void;
+    getCobuildLockProviderFactory(cobuildLockProviderName: string): CobuildLockProviderFactory | undefined;
 }
 //# sourceMappingURL=RushSession.d.ts.map

package/lib-shim/helpers.d.ts

@@ -0,0 +1,21 @@
+import type { EnvironmentVariableNames } from '@microsoft/rush-lib';
+export declare const RUSH_LIB_NAME: '@microsoft/rush-lib';
+export declare const RUSH_LIB_PATH_ENV_VAR_NAME: typeof EnvironmentVariableNames.RUSH_LIB_PATH;
+export type RushLibModuleType = Record<string, unknown>;
+export interface ISdkContext {
+    rushLibModule: RushLibModuleType | undefined;
+}
+export declare const sdkContext: ISdkContext;
+/**
+ * Find the rush.json location and return the path, or undefined if a rush.json can't be found.
+ *
+ * @privateRemarks
+ * Keep this in sync with `RushConfiguration.tryFindRushJsonLocation`.
+ */
+export declare function tryFindRushJsonLocation(startingFolder: string): string | undefined;
+export declare function _require<TResult>(moduleName: string): TResult;
+/**
+ * Require `@microsoft/rush-lib` under the specified folder path.
+ */
+export declare function requireRushLibUnderFolderPath(folderPath: string): RushLibModuleType;
+//# sourceMappingURL=helpers.d.ts.map

package/lib-shim/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,eAAO,MAAM,aAAa,EAAE,qBAA6C,CAAC;AAC1E,eAAO,MAAM,0BAA0B,EAAE,OAAO,wBAAwB,CAAC,aAAgC,CAAC;AAE1G,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAExD,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,iBAAiB,GAAG,SAAS,CAAC;CAC9C;AAED,eAAO,MAAM,UAAU,EAAE,WAExB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoBlF;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAU7D;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAOnF"}

package/lib-shim/helpers.js

@@ -0,0 +1,83 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireRushLibUnderFolderPath = exports._require = exports.tryFindRushJsonLocation = exports.sdkContext = exports.RUSH_LIB_PATH_ENV_VAR_NAME = exports.RUSH_LIB_NAME = void 0;
+const path = __importStar(require("path"));
+const node_core_library_1 = require("@rushstack/node-core-library");
+exports.RUSH_LIB_NAME = '@microsoft/rush-lib';
+exports.RUSH_LIB_PATH_ENV_VAR_NAME = '_RUSH_LIB_PATH';
+exports.sdkContext = {
+    rushLibModule: undefined
+};
+/**
+ * Find the rush.json location and return the path, or undefined if a rush.json can't be found.
+ *
+ * @privateRemarks
+ * Keep this in sync with `RushConfiguration.tryFindRushJsonLocation`.
+ */
+function tryFindRushJsonLocation(startingFolder) {
+    let currentFolder = startingFolder;
+    // Look upwards at parent folders until we find a folder containing rush.json
+    for (let i = 0; i < 10; ++i) {
+        const rushJsonFilename = path.join(currentFolder, 'rush.json');
+        if (node_core_library_1.FileSystem.exists(rushJsonFilename)) {
+            return rushJsonFilename;
+        }
+        const parentFolder = path.dirname(currentFolder);
+        if (parentFolder === currentFolder) {
+            break;
+        }
+        currentFolder = parentFolder;
+    }
+    return undefined;
+}
+exports.tryFindRushJsonLocation = tryFindRushJsonLocation;
+function _require(moduleName) {
+    if (typeof __non_webpack_require__ === 'function') {
+        // If this library has been bundled with Webpack, we need to call the real `require` function
+        // that doesn't get turned into a `__webpack_require__` statement.
+        // `__non_webpack_require__` is a Webpack macro that gets turned into a `require` statement
+        // during bundling.
+        return __non_webpack_require__(moduleName);
+    }
+    else {
+        return require(moduleName);
+    }
+}
+exports._require = _require;
+/**
+ * Require `@microsoft/rush-lib` under the specified folder path.
+ */
+function requireRushLibUnderFolderPath(folderPath) {
+    const rushLibModulePath = node_core_library_1.Import.resolveModule({
+        modulePath: exports.RUSH_LIB_NAME,
+        baseFolderPath: folderPath
+    });
+    return _require(rushLibModulePath);
+}
+exports.requireRushLibUnderFolderPath = requireRushLibUnderFolderPath;
+//# sourceMappingURL=helpers.js.map

package/lib-shim/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3D,2CAA6B;AAC7B,oEAAkE;AAGrD,QAAA,aAAa,GAA0B,qBAAqB,CAAC;AAC7D,QAAA,0BAA0B,GAAkD,gBAAgB,CAAC;AAQ7F,QAAA,UAAU,GAAgB;IACrC,aAAa,EAAE,SAAS;CACzB,CAAC;AAEF;;;;;GAKG;AACH,SAAgB,uBAAuB,CAAC,cAAsB;IAC5D,IAAI,aAAa,GAAW,cAAc,CAAC;IAE3C,6EAA6E;IAC7E,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE;QACnC,MAAM,gBAAgB,GAAW,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QAEvE,IAAI,8BAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE;YACvC,OAAO,gBAAgB,CAAC;SACzB;QAED,MAAM,YAAY,GAAW,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACzD,IAAI,YAAY,KAAK,aAAa,EAAE;YAClC,MAAM;SACP;QAED,aAAa,GAAG,YAAY,CAAC;KAC9B;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AApBD,0DAoBC;AAED,SAAgB,QAAQ,CAAU,UAAkB;IAClD,IAAI,OAAO,uBAAuB,KAAK,UAAU,EAAE;QACjD,6FAA6F;QAC7F,kEAAkE;QAClE,2FAA2F;QAC3F,mBAAmB;QACnB,OAAO,uBAAuB,CAAC,UAAU,CAAC,CAAC;KAC5C;SAAM;QACL,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC;KAC5B;AACH,CAAC;AAVD,4BAUC;AAED;;GAEG;AACH,SAAgB,6BAA6B,CAAC,UAAkB;IAC9D,MAAM,iBAAiB,GAAW,0BAAM,CAAC,aAAa,CAAC;QACrD,UAAU,EAAE,qBAAa;QACzB,cAAc,EAAE,UAAU;KAC3B,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC;AACrC,CAAC;AAPD,sEAOC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport * as path from 'path';\nimport { Import, FileSystem } from '@rushstack/node-core-library';\nimport type { EnvironmentVariableNames } from '@microsoft/rush-lib';\n\nexport const RUSH_LIB_NAME: '@microsoft/rush-lib' = '@microsoft/rush-lib';\nexport const RUSH_LIB_PATH_ENV_VAR_NAME: typeof EnvironmentVariableNames.RUSH_LIB_PATH = '_RUSH_LIB_PATH';\n\nexport type RushLibModuleType = Record<string, unknown>;\n\nexport interface ISdkContext {\n  rushLibModule: RushLibModuleType | undefined;\n}\n\nexport const sdkContext: ISdkContext = {\n  rushLibModule: undefined\n};\n\n/**\n * Find the rush.json location and return the path, or undefined if a rush.json can't be found.\n *\n * @privateRemarks\n * Keep this in sync with `RushConfiguration.tryFindRushJsonLocation`.\n */\nexport function tryFindRushJsonLocation(startingFolder: string): string | undefined {\n  let currentFolder: string = startingFolder;\n\n  // Look upwards at parent folders until we find a folder containing rush.json\n  for (let i: number = 0; i < 10; ++i) {\n    const rushJsonFilename: string = path.join(currentFolder, 'rush.json');\n\n    if (FileSystem.exists(rushJsonFilename)) {\n      return rushJsonFilename;\n    }\n\n    const parentFolder: string = path.dirname(currentFolder);\n    if (parentFolder === currentFolder) {\n      break;\n    }\n\n    currentFolder = parentFolder;\n  }\n\n  return undefined;\n}\n\nexport function _require<TResult>(moduleName: string): TResult {\n  if (typeof __non_webpack_require__ === 'function') {\n    // If this library has been bundled with Webpack, we need to call the real `require` function\n    // that doesn't get turned into a `__webpack_require__` statement.\n    // `__non_webpack_require__` is a Webpack macro that gets turned into a `require` statement\n    // during bundling.\n    return __non_webpack_require__(moduleName);\n  } else {\n    return require(moduleName);\n  }\n}\n\n/**\n * Require `@microsoft/rush-lib` under the specified folder path.\n */\nexport function requireRushLibUnderFolderPath(folderPath: string): RushLibModuleType {\n  const rushLibModulePath: string = Import.resolveModule({\n    modulePath: RUSH_LIB_NAME,\n    baseFolderPath: folderPath\n  });\n\n  return _require(rushLibModulePath);\n}\n"]}

package/lib-shim/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqNA;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAO1E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA8MA;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAO1E"}