@yarnpkg/plugin-pnpm 2.0.0-rc.8 → 2.0.0

package/lib/PnpmLinker.d.ts

@@ -1,8 +1,11 @@
 import { Descriptor, FetchResult, Installer, InstallPackageExtraApi, Linker, LinkOptions, Locator, LocatorHash, MinimalLinkOptions, Package } from '@yarnpkg/core';
 import { PortablePath } from '@yarnpkg/fslib';
-export declare type PnpmCustomData = {
-    pathByLocator: Map<LocatorHash, PortablePath>;
+export type PnpmCustomData = {
     locatorByPath: Map<PortablePath, string>;
+    pathsByLocator: Map<LocatorHash, {
+        packageLocation: PortablePath;
+        dependenciesLocation: PortablePath | null;
+    }>;
 };
 export declare class PnpmLinker implements Linker {
     getCustomDataKey(): string;
@@ -15,23 +18,21 @@ export declare class PnpmLinker implements Linker {
 declare class PnpmInstaller implements Installer {
     private opts;
     private readonly asyncActions;
+    private readonly indexFolderPromise;
     constructor(opts: LinkOptions);
     private customData;
     attachCustomData(customData: any): void;
     installPackage(pkg: Package, fetchResult: FetchResult, api: InstallPackageExtraApi): Promise<{
         packageLocation: PortablePath;
-        buildDirective: null;
-    } | {
-        packageLocation: PortablePath;
-        buildDirective: import("@yarnpkg/core").BuildDirective[];
+        buildRequest: import("@yarnpkg/core").BuildRequest | null;
     }>;
     installPackageSoft(pkg: Package, fetchResult: FetchResult, api: InstallPackageExtraApi): Promise<{
         packageLocation: PortablePath;
-        buildDirective: null;
+        buildRequest: null;
     }>;
     installPackageHard(pkg: Package, fetchResult: FetchResult, api: InstallPackageExtraApi): Promise<{
         packageLocation: PortablePath;
-        buildDirective: import("@yarnpkg/core").BuildDirective[];
+        buildRequest: import("@yarnpkg/core").BuildRequest | null;
     }>;
     attachInternalDependencies(locator: Locator, dependencies: Array<[Descriptor, Locator]>): Promise<void>;
     attachExternalDependents(locator: Locator, dependentPaths: Array<PortablePath>): Promise<void>;

package/lib/PnpmLinker.js

@@ -9,7 +9,7 @@ class PnpmLinker {
     getCustomDataKey() {
         return JSON.stringify({
             name: `PnpmLinker`,
-            version: 2,
+            version: 3,
         });
     }
     supportsPackage(pkg, opts) {
@@ -22,10 +22,10 @@ class PnpmLinker {
         const customData = opts.project.linkersCustomData.get(customDataKey);
         if (!customData)
             throw new clipanion_1.UsageError(`The project in ${core_1.formatUtils.pretty(opts.project.configuration, `${opts.project.cwd}/package.json`, core_1.formatUtils.Type.PATH)} doesn't seem to have been installed - running an install there might help`);
-        const packageLocation = customData.pathByLocator.get(locator.locatorHash);
-        if (typeof packageLocation === `undefined`)
+        const packagePaths = customData.pathsByLocator.get(locator.locatorHash);
+        if (typeof packagePaths === `undefined`)
             throw new clipanion_1.UsageError(`Couldn't find ${core_1.structUtils.prettyLocator(opts.project.configuration, locator)} in the currently installed pnpm map - running an install might help`);
-        return packageLocation;
+        return packagePaths.packageLocation;
     }
     async findPackageLocator(location, opts) {
         if (!this.isEnabled(opts))
@@ -66,10 +66,12 @@ class PnpmInstaller {
         this.opts = opts;
         this.asyncActions = new core_1.miscUtils.AsyncActions(10);
         this.customData = {
-            pathByLocator: new Map(),
+            pathsByLocator: new Map(),
             locatorByPath: new Map(),
         };
-        // Nothing to do
+        this.indexFolderPromise = (0, fslib_1.setupCopyIndex)(fslib_1.xfs, {
+            indexPath: fslib_1.ppath.join(opts.project.configuration.get(`globalFolder`), `index`),
+        });
     }
     attachCustomData(customData) {
         // We don't want to attach the data because it's only used in the Linker and we'll recompute it anyways in the Installer,
@@ -83,40 +85,51 @@ class PnpmInstaller {
         throw new Error(`Assertion failed: Unsupported package link type`);
     }
     async installPackageSoft(pkg, fetchResult, api) {
-        const pkgPath = fslib_1.ppath.resolve(fetchResult.packageFs.getRealPath(), fetchResult.prefixPath);
-        this.customData.pathByLocator.set(pkg.locatorHash, pkgPath);
+        const packageLocation = fslib_1.ppath.resolve(fetchResult.packageFs.getRealPath(), fetchResult.prefixPath);
+        const dependenciesLocation = this.opts.project.tryWorkspaceByLocator(pkg)
+            ? fslib_1.ppath.join(packageLocation, fslib_1.Filename.nodeModules)
+            : null;
+        this.customData.pathsByLocator.set(pkg.locatorHash, {
+            packageLocation,
+            dependenciesLocation,
+        });
         return {
-            packageLocation: pkgPath,
-            buildDirective: null,
+            packageLocation,
+            buildRequest: null,
         };
     }
     async installPackageHard(pkg, fetchResult, api) {
-        var _a;
-        const pkgPath = getPackageLocation(pkg, { project: this.opts.project });
-        this.customData.locatorByPath.set(pkgPath, core_1.structUtils.stringifyLocator(pkg));
-        this.customData.pathByLocator.set(pkg.locatorHash, pkgPath);
+        const packagePaths = getPackagePaths(pkg, { project: this.opts.project });
+        const packageLocation = packagePaths.packageLocation;
+        this.customData.locatorByPath.set(packageLocation, core_1.structUtils.stringifyLocator(pkg));
+        this.customData.pathsByLocator.set(pkg.locatorHash, packagePaths);
         api.holdFetchResult(this.asyncActions.set(pkg.locatorHash, async () => {
-            await fslib_1.xfs.mkdirPromise(pkgPath, { recursive: true });
+            await fslib_1.xfs.mkdirPromise(packageLocation, { recursive: true });
             // Copy the package source into the <root>/n_m/.store/<hash> directory, so
             // that we can then create symbolic links to it later.
-            await fslib_1.xfs.copyPromise(pkgPath, fetchResult.prefixPath, {
+            await fslib_1.xfs.copyPromise(packageLocation, fetchResult.prefixPath, {
                 baseFs: fetchResult.packageFs,
                 overwrite: false,
+                linkStrategy: {
+                    type: `HardlinkFromIndex`,
+                    indexPath: await this.indexFolderPromise,
+                    autoRepair: true,
+                },
             });
         }));
         const isVirtual = core_1.structUtils.isVirtualLocator(pkg);
         const devirtualizedLocator = isVirtual ? core_1.structUtils.devirtualizeLocator(pkg) : pkg;
         const buildConfig = {
-            manifest: (_a = await core_1.Manifest.tryFind(fetchResult.prefixPath, { baseFs: fetchResult.packageFs })) !== null && _a !== void 0 ? _a : new core_1.Manifest(),
+            manifest: await core_1.Manifest.tryFind(fetchResult.prefixPath, { baseFs: fetchResult.packageFs }) ?? new core_1.Manifest(),
             misc: {
                 hasBindingGyp: plugin_pnp_1.jsInstallUtils.hasBindingGyp(fetchResult),
             },
         };
         const dependencyMeta = this.opts.project.getDependencyMeta(devirtualizedLocator, pkg.version);
-        const buildScripts = plugin_pnp_1.jsInstallUtils.extractBuildScripts(pkg, buildConfig, dependencyMeta, { configuration: this.opts.project.configuration, report: this.opts.report });
+        const buildRequest = plugin_pnp_1.jsInstallUtils.extractBuildRequest(pkg, buildConfig, dependencyMeta, { configuration: this.opts.project.configuration });
         return {
-            packageLocation: pkgPath,
-            buildDirective: buildScripts,
+            packageLocation,
+            buildRequest,
         };
     }
     async attachInternalDependencies(locator, dependencies) {
@@ -125,31 +138,33 @@ class PnpmInstaller {
         // We don't install those packages at all, because they can't be used anyway
         if (!isPnpmVirtualCompatible(locator, { project: this.opts.project }))
             return;
+        const packagePaths = this.customData.pathsByLocator.get(locator.locatorHash);
+        if (typeof packagePaths === `undefined`)
+            throw new Error(`Assertion failed: Expected the package to have been registered (${core_1.structUtils.stringifyLocator(locator)})`);
+        const { dependenciesLocation, } = packagePaths;
+        if (!dependenciesLocation)
+            return;
         this.asyncActions.reduce(locator.locatorHash, async (action) => {
-            // Wait that the package is properly installed before starting to copy things into it
-            await action;
-            const pkgPath = this.customData.pathByLocator.get(locator.locatorHash);
-            if (typeof pkgPath === `undefined`)
-                throw new Error(`Assertion failed: Expected the package to have been registered (${core_1.structUtils.stringifyLocator(locator)})`);
-            const nmPath = fslib_1.ppath.join(pkgPath, fslib_1.Filename.nodeModules);
-            const concurrentPromises = [];
+            await fslib_1.xfs.mkdirPromise(dependenciesLocation, { recursive: true });
             // Retrieve what's currently inside the package's true nm folder. We
             // will use that to figure out what are the extraneous entries we'll
             // need to remove.
-            const extraneous = await getNodeModulesListing(nmPath);
-            for (const [descriptor, dependency] of dependencies) {
+            const initialEntries = await getNodeModulesListing(dependenciesLocation);
+            const extraneous = new Map(initialEntries);
+            const concurrentPromises = [action];
+            const installDependency = (descriptor, dependency) => {
                 // Downgrade virtual workspaces (cf isPnpmVirtualCompatible's documentation)
                 let targetDependency = dependency;
                 if (!isPnpmVirtualCompatible(dependency, { project: this.opts.project })) {
-                    this.opts.report.reportWarning(core_1.MessageName.UNNAMED, `The pnpm linker doesn't support providing different versions to workspaces' peer dependencies`);
+                    this.opts.report.reportWarningOnce(core_1.MessageName.UNNAMED, `The pnpm linker doesn't support providing different versions to workspaces' peer dependencies`);
                     targetDependency = core_1.structUtils.devirtualizeLocator(dependency);
                 }
-                const depSrcPath = this.customData.pathByLocator.get(targetDependency.locatorHash);
-                if (typeof depSrcPath === `undefined`)
+                const depSrcPaths = this.customData.pathsByLocator.get(targetDependency.locatorHash);
+                if (typeof depSrcPaths === `undefined`)
                     throw new Error(`Assertion failed: Expected the package to have been registered (${core_1.structUtils.stringifyLocator(dependency)})`);
                 const name = core_1.structUtils.stringifyIdent(descriptor);
-                const depDstPath = fslib_1.ppath.join(nmPath, name);
-                const depLinkPath = fslib_1.ppath.relative(fslib_1.ppath.dirname(depDstPath), depSrcPath);
+                const depDstPath = fslib_1.ppath.join(dependenciesLocation, name);
+                const depLinkPath = fslib_1.ppath.relative(fslib_1.ppath.dirname(depDstPath), depSrcPaths.packageLocation);
                 const existing = extraneous.get(name);
                 extraneous.delete(name);
                 concurrentPromises.push(Promise.resolve().then(async () => {
@@ -163,15 +178,23 @@ class PnpmInstaller {
                         }
                     }
                     await fslib_1.xfs.mkdirpPromise(fslib_1.ppath.dirname(depDstPath));
-                    if (process.platform == `win32`) {
-                        await fslib_1.xfs.symlinkPromise(depSrcPath, depDstPath, `junction`);
+                    if (process.platform == `win32` && this.opts.project.configuration.get(`winLinkType`) === core_1.WindowsLinkType.JUNCTIONS) {
+                        await fslib_1.xfs.symlinkPromise(depSrcPaths.packageLocation, depDstPath, `junction`);
                     }
                     else {
                         await fslib_1.xfs.symlinkPromise(depLinkPath, depDstPath);
                     }
                 }));
+            };
+            let hasExplicitSelfDependency = false;
+            for (const [descriptor, dependency] of dependencies) {
+                if (descriptor.identHash === locator.identHash)
+                    hasExplicitSelfDependency = true;
+                installDependency(descriptor, dependency);
             }
-            concurrentPromises.push(cleanNodeModules(nmPath, extraneous));
+            if (!hasExplicitSelfDependency && !this.opts.project.tryWorkspaceByLocator(locator))
+                installDependency(core_1.structUtils.convertLocatorToDescriptor(locator), locator);
+            concurrentPromises.push(cleanNodeModules(dependenciesLocation, extraneous));
             await Promise.all(concurrentPromises);
         });
     }
@@ -184,46 +207,25 @@ class PnpmInstaller {
             await fslib_1.xfs.removePromise(storeLocation);
         }
         else {
-            const removals = [];
-            const expectedEntries = new Set();
-            for (const packageLocation of this.customData.pathByLocator.values()) {
-                const subpath = fslib_1.ppath.contains(storeLocation, packageLocation);
-                if (subpath !== null) {
-                    const [storeEntry, /* Filename.nodeModules */ , ...identComponents] = subpath.split(fslib_1.ppath.sep);
-                    expectedEntries.add(storeEntry);
-                    const storeEntryPath = fslib_1.ppath.join(storeLocation, storeEntry);
-                    removals.push(fslib_1.xfs.readdirPromise(storeEntryPath)
-                        .then(entries => {
-                        return Promise.all(entries.map(async (entry) => {
-                            const p = fslib_1.ppath.join(storeEntryPath, entry);
-                            if (entry === fslib_1.Filename.nodeModules) {
-                                const extraneous = await getNodeModulesListing(p);
-                                extraneous.delete(identComponents.join(fslib_1.ppath.sep));
-                                return cleanNodeModules(p, extraneous);
-                            }
-                            else {
-                                return fslib_1.xfs.removePromise(p);
-                            }
-                        }));
-                    })
-                        .catch(error => {
-                        if (error.code !== `ENOENT`) {
-                            throw error;
-                        }
-                    }));
-                }
-            }
-            let storeRecords;
+            let extraneous;
             try {
-                storeRecords = await fslib_1.xfs.readdirPromise(storeLocation);
+                extraneous = new Set(await fslib_1.xfs.readdirPromise(storeLocation));
             }
             catch {
-                storeRecords = [];
+                extraneous = new Set();
+            }
+            for (const { dependenciesLocation } of this.customData.pathsByLocator.values()) {
+                if (!dependenciesLocation)
+                    continue;
+                const subpath = fslib_1.ppath.contains(storeLocation, dependenciesLocation);
+                if (subpath === null)
+                    continue;
+                const [storeEntry] = subpath.split(fslib_1.ppath.sep);
+                extraneous.delete(storeEntry);
             }
-            for (const record of storeRecords)
-                if (!expectedEntries.has(record))
-                    removals.push(fslib_1.xfs.removePromise(fslib_1.ppath.join(storeLocation, record)));
-            await Promise.all(removals);
+            await Promise.all([...extraneous].map(async (extraneousEntry) => {
+                await fslib_1.xfs.removePromise(fslib_1.ppath.join(storeLocation, extraneousEntry));
+            }));
         }
         // Wait for the package installs to catch up
         await this.asyncActions.wait();
@@ -241,11 +243,12 @@ function getNodeModulesLocation(project) {
 function getStoreLocation(project) {
     return fslib_1.ppath.join(getNodeModulesLocation(project), `.store`);
 }
-function getPackageLocation(locator, { project }) {
+function getPackagePaths(locator, { project }) {
     const pkgKey = core_1.structUtils.slugifyLocator(locator);
-    const prefixPath = core_1.structUtils.getIdentVendorPath(locator);
-    const pkgPath = fslib_1.ppath.join(getStoreLocation(project), pkgKey, prefixPath);
-    return pkgPath;
+    const storeLocation = getStoreLocation(project);
+    const packageLocation = fslib_1.ppath.join(storeLocation, pkgKey, `package`);
+    const dependenciesLocation = fslib_1.ppath.join(storeLocation, pkgKey, fslib_1.Filename.nodeModules);
+    return { packageLocation, dependenciesLocation };
 }
 function isPnpmVirtualCompatible(locator, { project }) {
     // The pnpm install strategy has a limitation: because Node would always
@@ -300,12 +303,11 @@ async function getNodeModulesListing(nmPath) {
     return listing;
 }
 async function cleanNodeModules(nmPath, extraneous) {
-    var _a;
     const removeNamePromises = [];
     const scopesToRemove = new Set();
     for (const name of extraneous.keys()) {
         removeNamePromises.push(fslib_1.xfs.removePromise(fslib_1.ppath.join(nmPath, name)));
-        const scope = (_a = core_1.structUtils.tryParseIdent(name)) === null || _a === void 0 ? void 0 : _a.scope;
+        const scope = core_1.structUtils.tryParseIdent(name)?.scope;
         if (scope) {
             scopesToRemove.add(`@${scope}`);
         }

package/lib/index.d.ts

@@ -1,3 +1,5 @@
 import { Plugin } from '@yarnpkg/core';
+import { PnpmLinker } from './PnpmLinker';
+export { PnpmLinker };
 declare const plugin: Plugin;
 export default plugin;

package/lib/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmLinker = void 0;
 const PnpmLinker_1 = require("./PnpmLinker");
+Object.defineProperty(exports, "PnpmLinker", { enumerable: true, get: function () { return PnpmLinker_1.PnpmLinker; } });
 const plugin = {
     linkers: [
         PnpmLinker_1.PnpmLinker,

package/package.json

@@ -1,23 +1,27 @@
 {
   "name": "@yarnpkg/plugin-pnpm",
-  "version": "2.0.0-rc.8",
+  "version": "2.0.0",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
   "dependencies": {
-    "@yarnpkg/fslib": "^3.0.0-rc.8",
-    "@yarnpkg/plugin-pnp": "^4.0.0-rc.8",
-    "@yarnpkg/plugin-stage": "^4.0.0-rc.8",
-    "clipanion": "^3.2.0-rc.10",
+    "@yarnpkg/fslib": "^3.0.0",
+    "@yarnpkg/plugin-pnp": "^4.0.0",
+    "@yarnpkg/plugin-stage": "^4.0.0",
+    "clipanion": "^4.0.0-rc.2",
     "p-limit": "^2.2.0",
-    "tslib": "^1.13.0"
+    "tslib": "^2.4.0"
   },
   "peerDependencies": {
-    "@yarnpkg/cli": "^4.0.0-rc.8",
-    "@yarnpkg/core": "^4.0.0-rc.8"
+    "@yarnpkg/cli": "^4.0.0",
+    "@yarnpkg/core": "^4.0.0"
   },
   "devDependencies": {
-    "@yarnpkg/cli": "^4.0.0-rc.8",
-    "@yarnpkg/core": "^4.0.0-rc.8"
+    "@yarnpkg/cli": "^4.0.0",
+    "@yarnpkg/core": "^4.0.0"
   },
   "repository": {
     "type": "git",
@@ -30,14 +34,15 @@
   },
   "publishConfig": {
     "main": "./lib/index.js",
-    "typings": "./lib/index.d.ts"
+    "exports": {
+      ".": "./lib/index.js",
+      "./package.json": "./package.json"
+    }
   },
   "files": [
     "/lib/**/*"
   ],
   "engines": {
-    "node": ">=14.15.0"
-  },
-  "stableVersion": "1.1.0",
-  "typings": "./lib/index.d.ts"
+    "node": ">=18.12.0"
+  }
 }