@yarnpkg/nm 4.0.7 → 4.1.0

package/lib/buildPackageMap.d.ts

@@ -0,0 +1,18 @@
+import { PortablePath } from '@yarnpkg/fslib';
+import { PnpApi } from '@yarnpkg/pnp';
+import { NodeModulesTree } from './buildNodeModulesTree';
+export type PackageMap = {
+    packages: Record<string, PackageMapPackage>;
+};
+export type PackageMapPackage = {
+    url: string;
+    dependencies: Record<string, string>;
+};
+export type PackageMapOptions = {
+    basePath: PortablePath;
+    pnp?: PnpApi | null;
+};
+export type LoosePackageMapOptions = {
+    basePath: PortablePath;
+};
+export declare const buildPackageMap: (nodeModulesTree: NodeModulesTree, { basePath, pnp }: PackageMapOptions) => PackageMap;

package/lib/buildPackageMap.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPackageMap = void 0;
+const core_1 = require("@yarnpkg/core");
+const fslib_1 = require("@yarnpkg/fslib");
+const buildNodeModulesTree_1 = require("./buildNodeModulesTree");
+const NODE_MODULES = `node_modules`;
+const WORKSPACE_NAME_SUFFIX = `$wsroot$`;
+const isPackageNode = (node) => {
+    return !node.dirList;
+};
+const stripTrailingSeparators = (path) => {
+    while (path !== fslib_1.PortablePath.root && path.endsWith(fslib_1.ppath.sep))
+        path = path.slice(0, -1);
+    return path;
+};
+const getPackagePath = (location, node) => {
+    return stripTrailingSeparators(node.linkType === buildNodeModulesTree_1.LinkType.SOFT ? node.target : location);
+};
+const getRelativeUrl = (from, to) => {
+    let relativePath = fslib_1.ppath.relative(from, to) || fslib_1.PortablePath.dot;
+    if (!relativePath.startsWith(`.`))
+        relativePath = `./${relativePath}`;
+    return relativePath;
+};
+const getPackageId = (basePath, location) => {
+    const relativePath = fslib_1.ppath.relative(basePath, location) || fslib_1.PortablePath.dot;
+    return relativePath === `..` ? fslib_1.PortablePath.dot : relativePath;
+};
+const getPackageName = (location) => {
+    const segments = location.split(fslib_1.ppath.sep);
+    const nodeModulesIndex = segments.lastIndexOf(NODE_MODULES);
+    if (nodeModulesIndex === -1)
+        return null;
+    const scopeOrName = segments[nodeModulesIndex + 1];
+    if (typeof scopeOrName === `undefined`)
+        return null;
+    const nodeModulesPath = segments.slice(0, nodeModulesIndex + 1).join(fslib_1.ppath.sep);
+    if (!scopeOrName.startsWith(`@`))
+        return { nodeModulesPath, packageName: scopeOrName };
+    const name = segments[nodeModulesIndex + 2];
+    if (typeof name === `undefined`)
+        return null;
+    return { nodeModulesPath, packageName: `${scopeOrName}/${name}` };
+};
+const compareStrings = (a, b) => {
+    return a < b ? -1 : a > b ? 1 : 0;
+};
+const getPackageDependencyNames = (pnp, node) => {
+    const locator = core_1.structUtils.parseLocator(node.locator.replace(WORKSPACE_NAME_SUFFIX, ``));
+    const packageInformation = pnp.getPackageInformation({
+        name: core_1.structUtils.stringifyIdent(locator),
+        reference: locator.reference,
+    });
+    if (packageInformation === null)
+        throw new Error(`Assertion failed: Expected ${node.locator} to have been registered`);
+    const dependencyNames = new Set();
+    for (const [dependencyName, dependencyReference] of packageInformation.packageDependencies)
+        if (dependencyReference !== null)
+            dependencyNames.add(dependencyName);
+    return dependencyNames;
+};
+const buildPackageMapFromDependencyFilter = (nodeModulesTree, { basePath }, getDependencyNames) => {
+    const packageMapNodes = new Map();
+    const packageLocationsByNodeModulesPath = new Map();
+    basePath = stripTrailingSeparators(basePath);
+    for (const [location, node] of nodeModulesTree) {
+        if (!isPackageNode(node))
+            continue;
+        const normalizedLocation = stripTrailingSeparators(location);
+        const packageMapNode = {
+            id: getPackageId(basePath, normalizedLocation),
+            packagePath: getPackagePath(normalizedLocation, node),
+            dependencyNames: getDependencyNames(node),
+        };
+        packageMapNodes.set(normalizedLocation, packageMapNode);
+        const packageName = getPackageName(normalizedLocation);
+        if (packageName !== null) {
+            let packageLocations = packageLocationsByNodeModulesPath.get(packageName.nodeModulesPath);
+            if (typeof packageLocations === `undefined`) {
+                packageLocations = new Map();
+                packageLocationsByNodeModulesPath.set(packageName.nodeModulesPath, packageLocations);
+            }
+            packageLocations.set(packageName.packageName, normalizedLocation);
+        }
+    }
+    const getPackageDependencies = (packagePath, dependencyNames) => {
+        const dependencies = new Map();
+        let currentPath = packagePath;
+        while (true) {
+            const nodeModulesPath = fslib_1.ppath.join(currentPath, NODE_MODULES);
+            const packageLocations = packageLocationsByNodeModulesPath.get(nodeModulesPath);
+            if (typeof packageLocations !== `undefined`) {
+                for (const [dependencyName, dependencyLocation] of Array.from(packageLocations).sort(([a], [b]) => compareStrings(a, b))) {
+                    if (dependencyNames !== null && !dependencyNames.has(dependencyName))
+                        continue;
+                    if (dependencies.has(dependencyName))
+                        continue;
+                    const dependency = packageMapNodes.get(dependencyLocation);
+                    if (typeof dependency === `undefined`)
+                        throw new Error(`Assertion failed: Expected ${dependencyLocation} to have been registered`);
+                    dependencies.set(dependencyName, dependency.id);
+                }
+            }
+            const parentPath = fslib_1.ppath.dirname(currentPath);
+            if (parentPath === currentPath)
+                break;
+            currentPath = parentPath;
+        }
+        return Object.fromEntries(Array.from(dependencies).sort(([a], [b]) => compareStrings(a, b)));
+    };
+    const packages = {};
+    for (const packageMapNode of Array.from(packageMapNodes.values()).sort((a, b) => compareStrings(a.id, b.id))) {
+        packages[packageMapNode.id] = {
+            url: getRelativeUrl(basePath, packageMapNode.packagePath),
+            dependencies: getPackageDependencies(packageMapNode.packagePath, packageMapNode.dependencyNames),
+        };
+    }
+    return { packages };
+};
+const buildPackageMap = (nodeModulesTree, { basePath, pnp }) => {
+    return buildPackageMapFromDependencyFilter(nodeModulesTree, { basePath }, node => {
+        return pnp ? getPackageDependencyNames(pnp, node) : null;
+    });
+};
+exports.buildPackageMap = buildPackageMap;

package/lib/index.d.ts

@@ -1,8 +1,10 @@
 import { NodeModulesLocatorMap, getArchivePath } from './buildNodeModulesTree';
 import { buildNodeModulesTree, buildLocatorMap } from './buildNodeModulesTree';
+import { buildPackageMap } from './buildPackageMap';
 export type { NodeModulesBaseNode, NodeModulesPackageNode, NodeModulesTreeOptions, NodeModulesTree, } from './buildNodeModulesTree';
+export type { PackageMap, PackageMapPackage, PackageMapOptions, LoosePackageMapOptions, } from './buildPackageMap';
 export { NodeModulesHoistingLimits, } from './buildNodeModulesTree';
-export { buildNodeModulesTree, buildLocatorMap, getArchivePath, };
+export { buildNodeModulesTree, buildLocatorMap, getArchivePath, buildPackageMap, };
 export type { NodeModulesLocatorMap };
 export type { HoisterTree, HoisterResult } from './hoist';
 export { hoist, HoisterDependencyKind } from './hoist';

package/lib/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HoisterDependencyKind = exports.hoist = exports.getArchivePath = exports.buildLocatorMap = exports.buildNodeModulesTree = exports.NodeModulesHoistingLimits = void 0;
+exports.HoisterDependencyKind = exports.hoist = exports.buildPackageMap = exports.getArchivePath = exports.buildLocatorMap = exports.buildNodeModulesTree = exports.NodeModulesHoistingLimits = void 0;
 const buildNodeModulesTree_1 = require("./buildNodeModulesTree");
 Object.defineProperty(exports, "getArchivePath", { enumerable: true, get: function () { return buildNodeModulesTree_1.getArchivePath; } });
 const buildNodeModulesTree_2 = require("./buildNodeModulesTree");
 Object.defineProperty(exports, "buildNodeModulesTree", { enumerable: true, get: function () { return buildNodeModulesTree_2.buildNodeModulesTree; } });
 Object.defineProperty(exports, "buildLocatorMap", { enumerable: true, get: function () { return buildNodeModulesTree_2.buildLocatorMap; } });
+const buildPackageMap_1 = require("./buildPackageMap");
+Object.defineProperty(exports, "buildPackageMap", { enumerable: true, get: function () { return buildPackageMap_1.buildPackageMap; } });
 var buildNodeModulesTree_3 = require("./buildNodeModulesTree");
 Object.defineProperty(exports, "NodeModulesHoistingLimits", { enumerable: true, get: function () { return buildNodeModulesTree_3.NodeModulesHoistingLimits; } });
 var hoist_1 = require("./hoist");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarnpkg/nm",
-  "version": "4.0.7",
+  "version": "4.1.0",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "exports": {
@@ -10,9 +10,9 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@yarnpkg/core": "^4.4.2",
-    "@yarnpkg/fslib": "^3.1.2",
-    "@yarnpkg/pnp": "^4.1.1"
+    "@yarnpkg/core": "^4.9.0",
+    "@yarnpkg/fslib": "^3.1.5",
+    "@yarnpkg/pnp": "^4.1.7"
   },
   "scripts": {
     "postpack": "rm -rf lib",