JezK
Edit File: generate-pnp-map.js
"use strict"; var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); var _typeof = require("@babel/runtime/helpers/typeof"); Object.defineProperty(exports, "__esModule", { value: true }); exports.generatePnpMap = generatePnpMap; function _regenerator() { var data = _interopRequireDefault(require("@babel/runtime/regenerator")); _regenerator = function _regenerator() { return data; }; return data; } function _toConsumableArray2() { var data = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray")); _toConsumableArray2 = function _toConsumableArray2() { return data; }; return data; } function _toArray2() { var data = _interopRequireDefault(require("@babel/runtime/helpers/toArray")); _toArray2 = function _toArray2() { return data; }; return data; } function _asyncToGenerator2() { var data = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator")); _asyncToGenerator2 = function _asyncToGenerator2() { return data; }; return data; } function _slicedToArray2() { var data = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray")); _slicedToArray2 = function _slicedToArray2() { return data; }; return data; } function _generatePnpMapApiTpl() { var data = _interopRequireDefault(require("./generate-pnp-map-api.tpl.js")); _generatePnpMapApiTpl = function _generatePnpMapApiTpl() { return data; }; return data; } function fs() { var data = _interopRequireWildcard(require("./fs.js")); fs = function fs() { return data; }; return data; } function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } var crypto = require('crypto'); var invariant = require('invariant'); var path = require('path'); var backwardSlashRegExp = /\\/g; var OFFLINE_CACHE_EXTENSION = ".zip"; function generateMaps(packageInformationStores, blacklistedLocations) { var code = ""; // Bake the information stores into our generated code code += "let packageInformationStores = new Map([\n"; var _iterator = _createForOfIteratorHelper(packageInformationStores), _step; try { for (_iterator.s(); !(_step = _iterator.n()).done;) { var _step$value = (0, _slicedToArray2()["default"])(_step.value, 2), packageName = _step$value[0], packageInformationStore = _step$value[1]; code += " [".concat(JSON.stringify(packageName), ", new Map([\n"); var _iterator4 = _createForOfIteratorHelper(packageInformationStore), _step4; try { for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { var _step4$value = (0, _slicedToArray2()["default"])(_step4.value, 2), packageReference = _step4$value[0], _step4$value$ = _step4$value[1], packageLocation = _step4$value$.packageLocation, packageDependencies = _step4$value$.packageDependencies; code += " [".concat(JSON.stringify(packageReference), ", {\n"); code += " packageLocation: path.resolve(__dirname, ".concat(JSON.stringify(packageLocation), "),\n"); code += " packageDependencies: new Map([\n"; var _iterator5 = _createForOfIteratorHelper(packageDependencies.entries()), _step5; try { for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { var _step5$value = (0, _slicedToArray2()["default"])(_step5.value, 2), dependencyName = _step5$value[0], dependencyReference = _step5$value[1]; code += " [".concat(JSON.stringify(dependencyName), ", ").concat(JSON.stringify(dependencyReference), "],\n"); } } catch (err) { _iterator5.e(err); } finally { _iterator5.f(); } code += " ]),\n"; code += " }],\n"; } } catch (err) { _iterator4.e(err); } finally { _iterator4.f(); } code += " ])],\n"; } } catch (err) { _iterator.e(err); } finally { _iterator.f(); } code += "]);\n"; code += "\n"; // Also bake an inverse map that will allow us to find the package information based on the path code += "let locatorsByLocations = new Map([\n"; var _iterator2 = _createForOfIteratorHelper(blacklistedLocations), _step2; try { for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { var blacklistedLocation = _step2.value; code += " [".concat(JSON.stringify(blacklistedLocation), ", blacklistedLocator],\n"); } } catch (err) { _iterator2.e(err); } finally { _iterator2.f(); } var _iterator3 = _createForOfIteratorHelper(packageInformationStores), _step3; try { for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { var _step3$value = (0, _slicedToArray2()["default"])(_step3.value, 2), _packageName = _step3$value[0], _packageInformationStore = _step3$value[1]; var _iterator6 = _createForOfIteratorHelper(_packageInformationStore), _step6; try { for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) { var _step6$value = (0, _slicedToArray2()["default"])(_step6.value, 2), _packageReference = _step6$value[0], _packageLocation = _step6$value[1].packageLocation; if (_packageName !== null) { code += " [".concat(JSON.stringify(_packageLocation), ", ").concat(JSON.stringify({ name: _packageName, reference: _packageReference }), "],\n"); } else { code += " [".concat(JSON.stringify(_packageLocation), ", topLevelLocator],\n"); } } } catch (err) { _iterator6.e(err); } finally { _iterator6.f(); } } } catch (err) { _iterator3.e(err); } finally { _iterator3.f(); } code += "]);\n"; return code; } function generateFindPackageLocator(packageInformationStores) { var code = ""; // We get the list of each string length we'll need to check in order to find the current package context var lengths = new Map(); var _iterator7 = _createForOfIteratorHelper(packageInformationStores.values()), _step7; try { for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) { var packageInformationStore = _step7.value; var _iterator9 = _createForOfIteratorHelper(packageInformationStore.values()), _step9; try { for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) { var packageLocation = _step9.value.packageLocation; if (packageLocation === null) { continue; } var length = packageLocation.length; var count = (lengths.get(length) || 0) + 1; lengths.set(length, count); } } catch (err) { _iterator9.e(err); } finally { _iterator9.f(); } } // We must try the larger lengths before the smaller ones, because smaller ones might also match the longest ones // (for instance, /project/path will match /project/path/.pnp/global/node_modules/pnp-cf5f9c17b8f8db) } catch (err) { _iterator7.e(err); } finally { _iterator7.f(); } var sortedLengths = Array.from(lengths.entries()).sort(function (a, b) { return b[0] - a[0]; }); // Generate a function that, given a file path, returns the associated package name code += "exports.findPackageLocator = function findPackageLocator(location) {\n"; code += " let relativeLocation = normalizePath(path.relative(__dirname, location));\n"; code += "\n"; code += " if (!relativeLocation.match(isStrictRegExp))\n"; code += " relativeLocation = `./${relativeLocation}`;\n"; code += "\n"; code += " if (location.match(isDirRegExp) && relativeLocation.charAt(relativeLocation.length - 1) !== '/')\n"; code += " relativeLocation = `${relativeLocation}/`;\n"; code += "\n"; code += " let match;\n"; var _iterator8 = _createForOfIteratorHelper(sortedLengths), _step8; try { for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) { var _step8$value = (0, _slicedToArray2()["default"])(_step8.value, 1), _length = _step8$value[0]; code += "\n"; code += " if (relativeLocation.length >= ".concat(_length, " && relativeLocation[").concat(_length - 1, "] === '/')\n"); code += " if (match = locatorsByLocations.get(relativeLocation.substr(0, ".concat(_length, ")))\n"); code += " return blacklistCheck(match);\n"; } } catch (err) { _iterator8.e(err); } finally { _iterator8.f(); } code += "\n"; code += " return null;\n"; code += "};\n"; return code; } function getPackageInformationStores(_x, _x2, _x3) { return _getPackageInformationStores.apply(this, arguments); } function _getPackageInformationStores() { _getPackageInformationStores = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee2(config, seedPatterns, _ref) { var resolver, reporter, targetPath, workspaceLayout, targetDirectory, offlineCacheFolder, packageInformationStores, blacklistedLocations, getCachePath, resolveOfflineCacheFolder, normalizePath, normalizeDirectoryPath, getHashFrom, getResolverEntry, visit, _i, _Object$keys, name, pkg, ref, loc, packageInformationStore; return _regenerator()["default"].wrap(function _callee2$(_context4) { while (1) switch (_context4.prev = _context4.next) { case 0: resolver = _ref.resolver, reporter = _ref.reporter, targetPath = _ref.targetPath, workspaceLayout = _ref.workspaceLayout; targetDirectory = path.dirname(targetPath); offlineCacheFolder = config.offlineCacheFolder; packageInformationStores = new Map(); blacklistedLocations = new Set(); getCachePath = function getCachePath(fsPath) { var cacheRelativePath = normalizePath(path.relative(config.cacheFolder, fsPath)); // if fsPath is not inside cacheRelativePath, we just skip it if (cacheRelativePath.match(/^\.\.\//)) { return null; } return cacheRelativePath; }; resolveOfflineCacheFolder = function resolveOfflineCacheFolder(fsPath) { if (!offlineCacheFolder) { return fsPath; } var cacheRelativePath = getCachePath(fsPath); // if fsPath is not inside the cache, we shouldn't replace it (workspace) if (!cacheRelativePath) { return fsPath; } var components = cacheRelativePath.split(/\//g); var _components = (0, _toArray2()["default"])(components), cacheEntry = _components[0], internalPath = _components.slice(1); return path.resolve(offlineCacheFolder, "".concat(cacheEntry).concat(OFFLINE_CACHE_EXTENSION), internalPath.join('/')); }; normalizePath = function normalizePath(fsPath) { return process.platform === 'win32' ? fsPath.replace(backwardSlashRegExp, '/') : fsPath; }; normalizeDirectoryPath = function normalizeDirectoryPath(fsPath) { var relativePath = normalizePath(path.relative(targetDirectory, resolveOfflineCacheFolder(fsPath))); if (!relativePath.match(/^\.{0,2}\//) && !path.isAbsolute(relativePath)) { relativePath = "./".concat(relativePath); } return relativePath.replace(/\/?$/, '/'); }; getHashFrom = function getHashFrom(data) { var hashGenerator = crypto.createHash('sha1'); var _iterator10 = _createForOfIteratorHelper(data), _step10; try { for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) { var datum = _step10.value; hashGenerator.update(datum); } } catch (err) { _iterator10.e(err); } finally { _iterator10.f(); } return hashGenerator.digest('hex'); }; getResolverEntry = function getResolverEntry(pattern) { var pkg = resolver.getStrictResolvedPattern(pattern); var ref = pkg._reference; if (!ref) { return null; } invariant(ref.locations.length <= 1, 'Must have at most one location (usually in the cache)'); var loc = ref.locations[0]; if (!loc) { return null; } return { pkg: pkg, ref: ref, loc: loc }; }; visit = /*#__PURE__*/function () { var _ref3 = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee(precomputedResolutions, seedPatterns) { var parentData, resolutions, locations, _iterator11, _step11, _loop, _ret, _iterator12, _step12, _loop2, _ret2, _args3 = arguments; return _regenerator()["default"].wrap(function _callee$(_context3) { while (1) switch (_context3.prev = _context3.next) { case 0: parentData = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : []; resolutions = new Map(precomputedResolutions); locations = new Map(); // This first pass will compute the package reference of each of the given patterns // They will usually be the package version, but not always. We need to do this in a pre-process pass, because the // dependencies might depend on one another, so if we need to replace one of them, we need to compute it first _iterator11 = _createForOfIteratorHelper(seedPatterns); _context3.prev = 4; _loop = /*#__PURE__*/_regenerator()["default"].mark(function _loop() { var pattern, entry, pkg, ref, loc, packageName, packageReference, peerDependencies, hash, symlinkSource, symlinkFile, isFromCache, hashName, newLoc, getBase; return _regenerator()["default"].wrap(function _loop$(_context) { while (1) switch (_context.prev = _context.next) { case 0: pattern = _step11.value; entry = getResolverEntry(pattern); if (entry) { _context.next = 4; break; } return _context.abrupt("return", "continue"); case 4: pkg = entry.pkg, ref = entry.ref; loc = entry.loc; packageName = pkg.name; packageReference = pkg.version; // If we have peer dependencies, then we generate a new virtual reference based on the parent one // We cannot generate this reference based on what those peer references resolve to, because they might not have // been computed yet (for example, consider the case where A has a peer dependency on B, and B a peer dependency // on A; it's valid, but it prevents us from computing A and B - and it's even worse with 3+ packages involved) peerDependencies = new Set(Array.from(Object.keys(pkg.peerDependencies || {}))); // As an optimization, we only setup virtual packages if their underlying packages are referenced multiple times // in the tree. This allow us to avoid having to create symlinks in the majority of cases if (!(peerDependencies.size > 0 && ref.requests.length > 1)) { _context.next = 30; break; } hash = getHashFrom([].concat((0, _toConsumableArray2()["default"])(parentData), [packageName, packageReference])); _context.t0 = ref.remote.type; _context.next = _context.t0 === 'workspace' ? 14 : 18; break; case 14: symlinkSource = loc; symlinkFile = path.resolve(config.lockfileFolder, '.pnp', 'workspaces', "pnp-".concat(hash), packageName); loc = symlinkFile; return _context.abrupt("break", 24); case 18: isFromCache = getCachePath(loc); hashName = isFromCache && offlineCacheFolder ? "pnp-".concat(hash).concat(OFFLINE_CACHE_EXTENSION) : "pnp-".concat(hash); newLoc = path.resolve(config.lockfileFolder, '.pnp', 'externals', hashName, 'node_modules', packageName); // The `node_modules/<pkgName>` part is already there when the package comes from the cache if (isFromCache) { getBase = function getBase(source) { return path.resolve(source, '../'.repeat(1 + packageName.split('/').length)); }; symlinkSource = resolveOfflineCacheFolder(getBase(loc)); symlinkFile = getBase(newLoc); } else { symlinkSource = loc; symlinkFile = newLoc; } loc = newLoc; return _context.abrupt("break", 24); case 24: _context.next = 26; return fs().mkdirp(path.dirname(symlinkFile)); case 26: _context.next = 28; return fs().symlink(symlinkSource, symlinkFile); case 28: packageReference = "pnp:".concat(hash); // We blacklist this path so that we can print a nicer error message if someone tries to require it (it usually // means that they're using realpath on the return value of require.resolve) blacklistedLocations.add(normalizeDirectoryPath(loc)); case 30: // Now that we have the final reference, we need to store it resolutions.set(packageName, packageReference); locations.set(packageName, loc); case 32: case "end": return _context.stop(); } }, _loop); }); _iterator11.s(); case 7: if ((_step11 = _iterator11.n()).done) { _context3.next = 14; break; } return _context3.delegateYield(_loop(), "t0", 9); case 9: _ret = _context3.t0; if (!(_ret === "continue")) { _context3.next = 12; break; } return _context3.abrupt("continue", 12); case 12: _context3.next = 7; break; case 14: _context3.next = 19; break; case 16: _context3.prev = 16; _context3.t1 = _context3["catch"](4); _iterator11.e(_context3.t1); case 19: _context3.prev = 19; _iterator11.f(); return _context3.finish(19); case 22: // Now that we have the final references, we can start the main loop, which will insert the packages into the store // if they aren't already there, and recurse over their own children _iterator12 = _createForOfIteratorHelper(seedPatterns); _context3.prev = 23; _loop2 = /*#__PURE__*/_regenerator()["default"].mark(function _loop2() { var pattern, entry, pkg, ref, packageName, packageReference, loc, packageInformationStore, packageInformation, peerDependencies, directDependencies, _iterator13, _step13, dependencyName, dependencyReference, childResolutions, _iterator14, _step14, _step14$value, name, reference; return _regenerator()["default"].wrap(function _loop2$(_context2) { while (1) switch (_context2.prev = _context2.next) { case 0: pattern = _step12.value; entry = getResolverEntry(pattern); if (entry) { _context2.next = 4; break; } return _context2.abrupt("return", "continue"); case 4: pkg = entry.pkg, ref = entry.ref; packageName = pkg.name; packageReference = resolutions.get(packageName); invariant(packageReference, "Package reference should have been computed during the pre-pass"); loc = locations.get(packageName); invariant(loc, "Package location should have been computed during the pre-pass"); // We can early exit if the package is already registered with the exact same name and reference, since even if // we might get slightly different dependencies (depending on how things were optimized), both sets are valid packageInformationStore = packageInformationStores.get(packageName); if (!packageInformationStore) { packageInformationStore = new Map(); packageInformationStores.set(packageName, packageInformationStore); } packageInformation = packageInformationStore.get(packageReference); if (!packageInformation) { _context2.next = 15; break; } return _context2.abrupt("return", "continue"); case 15: packageInformation = { packageLocation: normalizeDirectoryPath(loc), packageDependencies: new Map() }; // Split the dependencies between direct/peer - we will only recurse on the former peerDependencies = new Set(Array.from(Object.keys(pkg.peerDependencies || {}))); directDependencies = ref.dependencies.filter(function (pattern) { var pkg = resolver.getStrictResolvedPattern(pattern); return !pkg || !peerDependencies.has(pkg.name); }); // We inject the partial information in the store right now so that we won't cycle indefinitely packageInformationStore.set(packageReference, packageInformation); // We must inject the peer dependencies before iterating; one of our dependencies might have a peer dependency // on one of our peer dependencies, so it must be available from the start (we don't have to do that for direct // dependencies, because the "visit" function that will iterate over them will automatically add the to the // candidate resolutions as part of the first step, cf above) _iterator13 = _createForOfIteratorHelper(peerDependencies); try { for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) { dependencyName = _step13.value; dependencyReference = resolutions.get(dependencyName); if (dependencyReference) { packageInformation.packageDependencies.set(dependencyName, dependencyReference); } } } catch (err) { _iterator13.e(err); } finally { _iterator13.f(); } _context2.next = 23; return visit(packageInformation.packageDependencies, directDependencies, [packageName, packageReference]); case 23: childResolutions = _context2.sent; // We can now inject into our package the resolutions we got from the visit function _iterator14 = _createForOfIteratorHelper(childResolutions.entries()); try { for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) { _step14$value = (0, _slicedToArray2()["default"])(_step14.value, 2), name = _step14$value[0], reference = _step14$value[1]; packageInformation.packageDependencies.set(name, reference); } // Finally, unless a package depends on a previous version of itself (that would be weird but correct...), we // inject them an implicit dependency to themselves (so that they can require themselves) } catch (err) { _iterator14.e(err); } finally { _iterator14.f(); } if (!packageInformation.packageDependencies.has(packageName)) { packageInformation.packageDependencies.set(packageName, packageReference); } case 27: case "end": return _context2.stop(); } }, _loop2); }); _iterator12.s(); case 26: if ((_step12 = _iterator12.n()).done) { _context3.next = 33; break; } return _context3.delegateYield(_loop2(), "t2", 28); case 28: _ret2 = _context3.t2; if (!(_ret2 === "continue")) { _context3.next = 31; break; } return _context3.abrupt("continue", 31); case 31: _context3.next = 26; break; case 33: _context3.next = 38; break; case 35: _context3.prev = 35; _context3.t3 = _context3["catch"](23); _iterator12.e(_context3.t3); case 38: _context3.prev = 38; _iterator12.f(); return _context3.finish(38); case 41: return _context3.abrupt("return", resolutions); case 42: case "end": return _context3.stop(); } }, _callee, null, [[4, 16, 19, 22], [23, 35, 38, 41]]); })); return function visit(_x7, _x8) { return _ref3.apply(this, arguments); }; }(); // If we have workspaces, we need to iterate over them all in order to add them to the map // This is because they might not be declared as dependencies of the top-level project (and with reason, since the // top-level package might depend on a different than the one provided in the workspaces - cf Babel, which depends // on an old version of itself in order to compile itself) if (!workspaceLayout) { _context4.next = 37; break; } _i = 0, _Object$keys = Object.keys(workspaceLayout.workspaces); case 14: if (!(_i < _Object$keys.length)) { _context4.next = 37; break; } name = _Object$keys[_i]; pkg = workspaceLayout.workspaces[name].manifest; // Skip the aggregator, since it's essentially a duplicate of the top-level package that we'll iterate later on if (!pkg.workspaces) { _context4.next = 19; break; } return _context4.abrupt("continue", 34); case 19: ref = pkg._reference; invariant(ref, "Workspaces should have a reference"); invariant(ref.locations.length === 1, "Workspaces should have exactly one location"); loc = ref.locations[0]; invariant(loc, "Workspaces should have a location"); packageInformationStore = packageInformationStores.get(name); if (!packageInformationStore) { packageInformationStore = new Map(); packageInformationStores.set(name, packageInformationStore); } _context4.t0 = packageInformationStore; _context4.t1 = pkg.version; _context4.t2 = normalizeDirectoryPath(loc); _context4.next = 31; return visit(new Map(), ref.dependencies, [name, pkg.version]); case 31: _context4.t3 = _context4.sent; _context4.t4 = { packageLocation: _context4.t2, packageDependencies: _context4.t3 }; _context4.t0.set.call(_context4.t0, _context4.t1, _context4.t4); case 34: _i++; _context4.next = 14; break; case 37: _context4.t5 = packageInformationStores; _context4.t6 = Map; _context4.t7 = normalizeDirectoryPath(config.lockfileFolder); _context4.next = 42; return visit(new Map(), seedPatterns); case 42: _context4.t8 = _context4.sent; _context4.t9 = { packageLocation: _context4.t7, packageDependencies: _context4.t8 }; _context4.t10 = [null, _context4.t9]; _context4.t11 = [_context4.t10]; _context4.t12 = new _context4.t6(_context4.t11); _context4.t5.set.call(_context4.t5, null, _context4.t12); return _context4.abrupt("return", [packageInformationStores, blacklistedLocations]); case 49: case "end": return _context4.stop(); } }, _callee2); })); return _getPackageInformationStores.apply(this, arguments); } function generatePnpMap(_x4, _x5, _x6) { return _generatePnpMap.apply(this, arguments); } function _generatePnpMap() { _generatePnpMap = (0, _asyncToGenerator2()["default"])( /*#__PURE__*/_regenerator()["default"].mark(function _callee3(config, seedPatterns, _ref2) { var resolver, reporter, workspaceLayout, targetPath, _yield$getPackageInfo, _yield$getPackageInfo2, packageInformationStores, blacklistedLocations, setupStaticTables; return _regenerator()["default"].wrap(function _callee3$(_context5) { while (1) switch (_context5.prev = _context5.next) { case 0: resolver = _ref2.resolver, reporter = _ref2.reporter, workspaceLayout = _ref2.workspaceLayout, targetPath = _ref2.targetPath; _context5.next = 3; return getPackageInformationStores(config, seedPatterns, { resolver: resolver, reporter: reporter, targetPath: targetPath, workspaceLayout: workspaceLayout }); case 3: _yield$getPackageInfo = _context5.sent; _yield$getPackageInfo2 = (0, _slicedToArray2()["default"])(_yield$getPackageInfo, 2); packageInformationStores = _yield$getPackageInfo2[0]; blacklistedLocations = _yield$getPackageInfo2[1]; setupStaticTables = [generateMaps(packageInformationStores, blacklistedLocations), generateFindPackageLocator(packageInformationStores)].join(""); return _context5.abrupt("return", _generatePnpMapApiTpl()["default"].replace(/\$\$SHEBANG/g, config.plugnplayShebang).replace(/\$\$BLACKLIST/g, JSON.stringify(config.plugnplayBlacklist)).replace(/\$\$SETUP_STATIC_TABLES\(\);/g, setupStaticTables)); case 9: case "end": return _context5.stop(); } }, _callee3); })); return _generatePnpMap.apply(this, arguments); } //# sourceMappingURL=generate-pnp-map.js.map