@rushstack/rush-http-build-cache-plugin 5.97.1-pr3481.18 → 5.98.0

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/{42/Import_42731f0220476b7d949a2d8f3a6f3333 → 12/Import_12af6d2ca109ffba883fc5079062e0e8}

@@ -1,4 +1,4 @@
-209e9cf9090ea89efb6e5d699ef8c518
+17c8f45b5493500142a3994514f4c6eb
 "use strict";
 // Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
 // See LICENSE in the project root for license information.
@@ -145,32 +145,105 @@ class Import {
      * and a system module is found, then its name is returned without any file path.
      */
     static resolveModule(options) {
-        const { modulePath, baseFolderPath, includeSystemModules, allowSelfReference } = options;
+        const { modulePath, baseFolderPath, includeSystemModules, allowSelfReference, getRealPath } = options;
         if (path.isAbsolute(modulePath)) {
             return modulePath;
         }
-        const normalizedRootPath = FileSystem_1.FileSystem.getRealPath(baseFolderPath);
+        const normalizedRootPath = (getRealPath || FileSystem_1.FileSystem.getRealPath)(baseFolderPath);
         if (modulePath.startsWith('.')) {
             // This looks like a conventional relative path
             return path.resolve(normalizedRootPath, modulePath);
         }
-        if (includeSystemModules === true && Import._builtInModules.has(modulePath)) {
-            return modulePath;
+        // Built-in modules do not have a scope, so if there is a slash, then we need to check
+        // against the first path segment
+        const slashIndex = modulePath.indexOf('/');
+        const moduleName = slashIndex === -1 ? modulePath : modulePath.slice(0, slashIndex);
+        if (!includeSystemModules && Import._builtInModules.has(moduleName)) {
+            throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}".`);
         }
         if (allowSelfReference === true) {
             const ownPackage = Import._getPackageName(baseFolderPath);
-            if (ownPackage && modulePath.startsWith(ownPackage.packageName)) {
-                const packagePath = modulePath.substr(ownPackage.packageName.length + 1);
+            if (ownPackage &&
+                (modulePath === ownPackage.packageName || modulePath.startsWith(`${ownPackage.packageName}/`))) {
+                const packagePath = modulePath.slice(ownPackage.packageName.length + 1);
                 return path.resolve(ownPackage.packageRootPath, packagePath);
             }
         }
         try {
-            return Resolve.sync(
-            // Append a slash to the package name to ensure `resolve.sync` doesn't attempt to return a system package
-            includeSystemModules !== true && modulePath.indexOf('/') === -1 ? `${modulePath}/` : modulePath, {
+            return Resolve.sync(modulePath, {
                 basedir: normalizedRootPath,
-                preserveSymlinks: false
+                preserveSymlinks: false,
+                realpathSync: getRealPath
+            });
+        }
+        catch (e) {
+            throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}".`);
+        }
+    }
+    /**
+     * Async version of {@link Import.resolveModule}.
+     */
+    static async resolveModuleAsync(options) {
+        const { modulePath, baseFolderPath, includeSystemModules, allowSelfReference, getRealPath, getRealPathAsync } = options;
+        if (path.isAbsolute(modulePath)) {
+            return modulePath;
+        }
+        const normalizedRootPath = await (getRealPathAsync || getRealPath || FileSystem_1.FileSystem.getRealPathAsync)(baseFolderPath);
+        if (modulePath.startsWith('.')) {
+            // This looks like a conventional relative path
+            return path.resolve(normalizedRootPath, modulePath);
+        }
+        // Built-in modules do not have a scope, so if there is a slash, then we need to check
+        // against the first path segment
+        const slashIndex = modulePath.indexOf('/');
+        const moduleName = slashIndex === -1 ? modulePath : modulePath.slice(0, slashIndex);
+        if (!includeSystemModules && Import._builtInModules.has(moduleName)) {
+            throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}".`);
+        }
+        if (allowSelfReference === true) {
+            const ownPackage = Import._getPackageName(baseFolderPath);
+            if (ownPackage &&
+                (modulePath === ownPackage.packageName || modulePath.startsWith(`${ownPackage.packageName}/`))) {
+                const packagePath = modulePath.slice(ownPackage.packageName.length + 1);
+                return path.resolve(ownPackage.packageRootPath, packagePath);
+            }
+        }
+        try {
+            const resolvePromise = new Promise((resolve, reject) => {
+                const realPathFn = getRealPathAsync || getRealPath
+                    ? (filePath, callback) => {
+                        if (getRealPathAsync) {
+                            getRealPathAsync(filePath)
+                                .then((resolvedPath) => callback(null, resolvedPath))
+                                .catch((error) => callback(error));
+                        }
+                        else {
+                            try {
+                                const resolvedPath = getRealPath(filePath);
+                                callback(null, resolvedPath);
+                            }
+                            catch (error) {
+                                callback(error);
+                            }
+                        }
+                    }
+                    : undefined;
+                Resolve.default(modulePath, {
+                    basedir: normalizedRootPath,
+                    preserveSymlinks: false,
+                    realpath: realPathFn
+                }, (error, resolvedPath) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        // Resolve docs state that either an error will be returned, or the resolved path.
+                        // In this case, the resolved path should always be populated.
+                        resolve(resolvedPath);
+                    }
+                });
             });
+            return await resolvePromise;
         }
         catch (e) {
             throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}".`);
@@ -197,11 +270,11 @@ class Import {
      * and a system module is found, then its name is returned without any file path.
      */
     static resolvePackage(options) {
-        const { packageName, includeSystemModules, baseFolderPath, allowSelfReference } = options;
+        const { packageName, includeSystemModules, baseFolderPath, allowSelfReference, getRealPath } = options;
         if (includeSystemModules && Import._builtInModules.has(packageName)) {
             return packageName;
         }
-        const normalizedRootPath = FileSystem_1.FileSystem.getRealPath(baseFolderPath);
+        const normalizedRootPath = (getRealPath || FileSystem_1.FileSystem.getRealPath)(baseFolderPath);
         if (allowSelfReference) {
             const ownPackage = Import._getPackageName(baseFolderPath);
             if (ownPackage && ownPackage.packageName === packageName) {
@@ -221,8 +294,78 @@ class Import {
                     // even if the real entry point was in an subfolder with arbitrary nesting.
                     pkg.main = 'package.json';
                     return pkg;
-                }
+                },
+                realpathSync: getRealPath
+            });
+            const packagePath = path.dirname(resolvedPath);
+            return packagePath;
+        }
+        catch (_a) {
+            throw new Error(`Cannot find package "${packageName}" from "${baseFolderPath}".`);
+        }
+    }
+    /**
+     * Async version of {@link Import.resolvePackage}.
+     */
+    static async resolvePackageAsync(options) {
+        const { packageName, includeSystemModules, baseFolderPath, allowSelfReference, getRealPath, getRealPathAsync } = options;
+        if (includeSystemModules && Import._builtInModules.has(packageName)) {
+            return packageName;
+        }
+        const normalizedRootPath = await (getRealPathAsync || getRealPath || FileSystem_1.FileSystem.getRealPathAsync)(baseFolderPath);
+        if (allowSelfReference) {
+            const ownPackage = Import._getPackageName(baseFolderPath);
+            if (ownPackage && ownPackage.packageName === packageName) {
+                return ownPackage.packageRootPath;
+            }
+        }
+        PackageName_1.PackageName.parse(packageName); // Ensure the package name is valid and doesn't contain a path
+        try {
+            const resolvePromise = new Promise((resolve, reject) => {
+                const realPathFn = getRealPathAsync || getRealPath
+                    ? (filePath, callback) => {
+                        if (getRealPathAsync) {
+                            getRealPathAsync(filePath)
+                                .then((resolvedPath) => callback(null, resolvedPath))
+                                .catch((error) => callback(error));
+                        }
+                        else {
+                            try {
+                                const resolvedPath = getRealPath(filePath);
+                                callback(null, resolvedPath);
+                            }
+                            catch (error) {
+                                callback(error);
+                            }
+                        }
+                    }
+                    : undefined;
+                Resolve.default(
+                // Append a slash to the package name to ensure `resolve` doesn't attempt to return a system package
+                `${packageName}/`, {
+                    basedir: normalizedRootPath,
+                    preserveSymlinks: false,
+                    packageFilter: (pkg, pkgFile, dir) => {
+                        // Hardwire "main" to point to a file that is guaranteed to exist.
+                        // This helps resolve packages such as @types/node that have no entry point.
+                        // And then we can use path.dirname() below to locate the package folder,
+                        // even if the real entry point was in an subfolder with arbitrary nesting.
+                        pkg.main = 'package.json';
+                        return pkg;
+                    },
+                    realpath: realPathFn
+                }, (error, resolvedPath) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        // Resolve docs state that either an error will be returned, or the resolved path.
+                        // In this case, the resolved path should always be populated.
+                        resolve(resolvedPath);
+                    }
+                });
             });
+            const resolvedPath = await resolvePromise;
             const packagePath = path.dirname(resolvedPath);
             return packagePath;
         }