@pnpm/lockfile.fs 1001.1.31 → 1100.0.0

package/lib/envLockfile.d.ts

@@ -0,0 +1,4 @@
+import type { EnvLockfile } from '@pnpm/lockfile.types';
+export declare function createEnvLockfile(): EnvLockfile;
+export declare function readEnvLockfile(rootDir: string): Promise<EnvLockfile | null>;
+export declare function writeEnvLockfile(rootDir: string, lockfile: EnvLockfile): Promise<void>;

package/lib/envLockfile.js

@@ -0,0 +1,72 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { LOCKFILE_VERSION, WANTED_LOCKFILE } from '@pnpm/constants';
+import yaml from 'js-yaml';
+import writeFileAtomic from 'write-file-atomic';
+import { sortLockfileKeys } from './sortLockfileKeys.js';
+import { lockfileYamlDump } from './write.js';
+import { extractMainDocument, streamReadFirstYamlDocument } from './yamlDocuments.js';
+export function createEnvLockfile() {
+    return {
+        lockfileVersion: LOCKFILE_VERSION,
+        importers: {
+            '.': {
+                configDependencies: {},
+            },
+        },
+        packages: {},
+        snapshots: {},
+    };
+}
+export async function readEnvLockfile(rootDir) {
+    const lockfilePath = path.join(rootDir, WANTED_LOCKFILE);
+    const rawContent = await streamReadFirstYamlDocument(lockfilePath);
+    if (rawContent == null) {
+        return null;
+    }
+    const parsed = yaml.load(rawContent);
+    if (parsed == null || typeof parsed !== 'object') {
+        return null;
+    }
+    const lockfile = parsed;
+    if (typeof lockfile.lockfileVersion !== 'string') {
+        return null;
+    }
+    if (lockfile.importers == null || typeof lockfile.importers !== 'object') {
+        return null;
+    }
+    if (lockfile.packages == null || typeof lockfile.packages !== 'object') {
+        return null;
+    }
+    if (lockfile.snapshots == null || typeof lockfile.snapshots !== 'object') {
+        return null;
+    }
+    const envLockfile = parsed;
+    if (!envLockfile.importers['.']) {
+        envLockfile.importers['.'] = { configDependencies: {} };
+    }
+    else if (!envLockfile.importers['.'].configDependencies) {
+        envLockfile.importers['.'].configDependencies = {};
+    }
+    return envLockfile;
+}
+export async function writeEnvLockfile(rootDir, lockfile) {
+    const lockfilePath = path.join(rootDir, WANTED_LOCKFILE);
+    const sorted = sortLockfileKeys(lockfile);
+    const envYaml = lockfileYamlDump(sorted);
+    // Read existing main lockfile document to preserve it
+    let mainDoc = '';
+    try {
+        const existing = await fs.readFile(lockfilePath, 'utf8');
+        mainDoc = extractMainDocument(existing);
+    }
+    catch (err) {
+        if (!(util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {
+            throw err;
+        }
+    }
+    const combined = `---\n${envYaml}\n---\n${mainDoc}`;
+    return writeFileAtomic(lockfilePath, combined);
+}
+//# sourceMappingURL=envLockfile.js.map

package/lib/errors/LockfileBreakingChangeError.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LockfileBreakingChangeError = void 0;
-const error_1 = require("@pnpm/error");
-class LockfileBreakingChangeError extends error_1.PnpmError {
+import { PnpmError } from '@pnpm/error';
+export class LockfileBreakingChangeError extends PnpmError {
     filename;
     constructor(filename) {
         super('LOCKFILE_BREAKING_CHANGE', `Lockfile ${filename} not compatible with current pnpm`);
         this.filename = filename;
     }
 }
-exports.LockfileBreakingChangeError = LockfileBreakingChangeError;
 //# sourceMappingURL=LockfileBreakingChangeError.js.map

package/lib/errors/index.js

@@ -1,6 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LockfileBreakingChangeError = void 0;
-var LockfileBreakingChangeError_js_1 = require("./LockfileBreakingChangeError.js");
-Object.defineProperty(exports, "LockfileBreakingChangeError", { enumerable: true, get: function () { return LockfileBreakingChangeError_js_1.LockfileBreakingChangeError; } });
+export { LockfileBreakingChangeError } from './LockfileBreakingChangeError.js';
 //# sourceMappingURL=index.js.map

package/lib/existsWantedLockfile.d.ts

@@ -1,6 +1,6 @@
-interface existsNonEmptyWantedLockfileOptions {
+interface ExistsNonEmptyWantedLockfileOptions {
     useGitBranchLockfile?: boolean;
     mergeGitBranchLockfiles?: boolean;
 }
-export declare function existsNonEmptyWantedLockfile(pkgPath: string, opts?: existsNonEmptyWantedLockfileOptions): Promise<boolean>;
+export declare function existsNonEmptyWantedLockfile(pkgPath: string, opts?: ExistsNonEmptyWantedLockfileOptions): Promise<boolean>;
 export {};

package/lib/existsWantedLockfile.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.existsNonEmptyWantedLockfile = existsNonEmptyWantedLockfile;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const lockfileName_js_1 = require("./lockfileName.js");
-async function existsNonEmptyWantedLockfile(pkgPath, opts = {
+import fs from 'node:fs';
+import path from 'node:path';
+import { getWantedLockfileName } from './lockfileName.js';
+export async function existsNonEmptyWantedLockfile(pkgPath, opts = {
     useGitBranchLockfile: false,
     mergeGitBranchLockfiles: false,
 }) {
-    const wantedLockfile = await (0, lockfileName_js_1.getWantedLockfileName)(opts);
+    const wantedLockfile = await getWantedLockfileName(opts);
     return new Promise((resolve, reject) => {
-        fs_1.default.access(path_1.default.join(pkgPath, wantedLockfile), (err) => {
+        fs.access(path.join(pkgPath, wantedLockfile), (err) => {
             if (err == null) {
                 resolve(true);
                 return;

package/lib/getLockfileImporterId.d.ts

@@ -1,2 +1,2 @@
-import { type ProjectId } from '@pnpm/types';
+import type { ProjectId } from '@pnpm/types';
 export declare function getLockfileImporterId(lockfileDir: string, prefix: string): ProjectId;

package/lib/getLockfileImporterId.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLockfileImporterId = getLockfileImporterId;
-const path_1 = __importDefault(require("path"));
-const normalize_path_1 = __importDefault(require("normalize-path"));
-function getLockfileImporterId(lockfileDir, prefix) {
-    return ((0, normalize_path_1.default)(path_1.default.relative(lockfileDir, prefix)) || '.');
+import path from 'node:path';
+import normalize from 'normalize-path';
+export function getLockfileImporterId(lockfileDir, prefix) {
+    return (normalize(path.relative(lockfileDir, prefix)) || '.');
 }
 //# sourceMappingURL=getLockfileImporterId.js.map

package/lib/gitBranchLockfile.js

@@ -1,23 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGitBranchLockfileNames = getGitBranchLockfileNames;
-exports.cleanGitBranchLockfiles = cleanGitBranchLockfiles;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-async function getGitBranchLockfileNames(lockfileDir) {
-    const files = await fs_1.promises.readdir(lockfileDir);
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export async function getGitBranchLockfileNames(lockfileDir) {
+    const files = await fs.readdir(lockfileDir);
     // eslint-disable-next-line regexp/no-useless-non-capturing-group
     const gitBranchLockfileNames = files.filter(file => file.match(/^pnpm-lock.(?:.*).yaml$/));
     return gitBranchLockfileNames;
 }
-async function cleanGitBranchLockfiles(lockfileDir) {
+export async function cleanGitBranchLockfiles(lockfileDir) {
     const gitBranchLockfiles = await getGitBranchLockfileNames(lockfileDir);
-    await Promise.all(gitBranchLockfiles.map(async (file) => {
-        const filepath = path_1.default.join(lockfileDir, file);
-        await fs_1.promises.unlink(filepath);
+    await Promise.all(gitBranchLockfiles.map(async file => {
+        const filepath = path.join(lockfileDir, file);
+        await fs.unlink(filepath);
     }));
 }
 //# sourceMappingURL=gitBranchLockfile.js.map

package/lib/gitMergeFile.d.ts

@@ -1,3 +1,3 @@
-import { type LockfileObject } from '@pnpm/lockfile.types';
+import type { LockfileObject } from '@pnpm/lockfile.types';
 export declare function autofixMergeConflicts(fileContent: string): LockfileObject;
 export declare function isDiff(fileContent: string): boolean;

package/lib/gitMergeFile.js

@@ -1,20 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.autofixMergeConflicts = autofixMergeConflicts;
-exports.isDiff = isDiff;
-const lockfile_merger_1 = require("@pnpm/lockfile.merger");
-const js_yaml_1 = __importDefault(require("js-yaml"));
-const lockfileFormatConverters_js_1 = require("./lockfileFormatConverters.js");
+import { mergeLockfileChanges } from '@pnpm/lockfile.merger';
+import yaml from 'js-yaml';
+import { convertToLockfileObject } from './lockfileFormatConverters.js';
 const MERGE_CONFLICT_PARENT = '|||||||';
 const MERGE_CONFLICT_END = '>>>>>>>';
 const MERGE_CONFLICT_THEIRS = '=======';
 const MERGE_CONFLICT_OURS = '<<<<<<<';
-function autofixMergeConflicts(fileContent) {
+export function autofixMergeConflicts(fileContent) {
     const { ours, theirs } = parseMergeFile(fileContent);
-    return (0, lockfile_merger_1.mergeLockfileChanges)((0, lockfileFormatConverters_js_1.convertToLockfileObject)(js_yaml_1.default.load(ours)), (0, lockfileFormatConverters_js_1.convertToLockfileObject)(js_yaml_1.default.load(theirs)));
+    return mergeLockfileChanges(convertToLockfileObject(yaml.load(ours)), convertToLockfileObject(yaml.load(theirs)));
 }
 function parseMergeFile(fileContent) {
     const lines = fileContent.split(/[\n\r]+/);
@@ -46,7 +39,7 @@ function parseMergeFile(fileContent) {
     }
     return { ours: ours.join('\n'), theirs: theirs.join('\n') };
 }
-function isDiff(fileContent) {
+export function isDiff(fileContent) {
     return fileContent.includes(MERGE_CONFLICT_OURS) &&
         fileContent.includes(MERGE_CONFLICT_THEIRS) &&
         fileContent.includes(MERGE_CONFLICT_END);

package/lib/index.d.ts

@@ -1,7 +1,9 @@
-export { isEmptyLockfile, writeLockfiles, writeCurrentLockfile, writeWantedLockfile, writeLockfileFile, } from './write.js';
+export { createEnvLockfile, readEnvLockfile, writeEnvLockfile } from './envLockfile.js';
 export { existsNonEmptyWantedLockfile } from './existsWantedLockfile.js';
 export { getLockfileImporterId } from './getLockfileImporterId.js';
-export * from '@pnpm/lockfile.types';
-export * from './read.js';
 export { cleanGitBranchLockfiles } from './gitBranchLockfile.js';
-export { convertToLockfileFile } from './lockfileFormatConverters.js';
+export { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
+export * from './read.js';
+export { isEmptyLockfile, writeCurrentLockfile, writeLockfileFile, writeLockfiles, writeWantedLockfile, } from './write.js';
+export { extractMainDocument } from './yamlDocuments.js';
+export * from '@pnpm/lockfile.types';

package/lib/index.js

@@ -1,34 +1,10 @@
-"use strict";
-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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToLockfileFile = exports.cleanGitBranchLockfiles = exports.getLockfileImporterId = exports.existsNonEmptyWantedLockfile = exports.writeLockfileFile = exports.writeWantedLockfile = exports.writeCurrentLockfile = exports.writeLockfiles = exports.isEmptyLockfile = void 0;
-var write_js_1 = require("./write.js");
-Object.defineProperty(exports, "isEmptyLockfile", { enumerable: true, get: function () { return write_js_1.isEmptyLockfile; } });
-Object.defineProperty(exports, "writeLockfiles", { enumerable: true, get: function () { return write_js_1.writeLockfiles; } });
-Object.defineProperty(exports, "writeCurrentLockfile", { enumerable: true, get: function () { return write_js_1.writeCurrentLockfile; } });
-Object.defineProperty(exports, "writeWantedLockfile", { enumerable: true, get: function () { return write_js_1.writeWantedLockfile; } });
-Object.defineProperty(exports, "writeLockfileFile", { enumerable: true, get: function () { return write_js_1.writeLockfileFile; } });
-var existsWantedLockfile_js_1 = require("./existsWantedLockfile.js");
-Object.defineProperty(exports, "existsNonEmptyWantedLockfile", { enumerable: true, get: function () { return existsWantedLockfile_js_1.existsNonEmptyWantedLockfile; } });
-var getLockfileImporterId_js_1 = require("./getLockfileImporterId.js");
-Object.defineProperty(exports, "getLockfileImporterId", { enumerable: true, get: function () { return getLockfileImporterId_js_1.getLockfileImporterId; } });
-__exportStar(require("@pnpm/lockfile.types"), exports);
-__exportStar(require("./read.js"), exports);
-var gitBranchLockfile_js_1 = require("./gitBranchLockfile.js");
-Object.defineProperty(exports, "cleanGitBranchLockfiles", { enumerable: true, get: function () { return gitBranchLockfile_js_1.cleanGitBranchLockfiles; } });
-var lockfileFormatConverters_js_1 = require("./lockfileFormatConverters.js");
-Object.defineProperty(exports, "convertToLockfileFile", { enumerable: true, get: function () { return lockfileFormatConverters_js_1.convertToLockfileFile; } });
+export { createEnvLockfile, readEnvLockfile, writeEnvLockfile } from './envLockfile.js';
+export { existsNonEmptyWantedLockfile } from './existsWantedLockfile.js';
+export { getLockfileImporterId } from './getLockfileImporterId.js';
+export { cleanGitBranchLockfiles } from './gitBranchLockfile.js';
+export { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
+export * from './read.js';
+export { isEmptyLockfile, writeCurrentLockfile, writeLockfileFile, writeLockfiles, writeWantedLockfile, } from './write.js';
+export { extractMainDocument } from './yamlDocuments.js';
+export * from '@pnpm/lockfile.types';
 //# sourceMappingURL=index.js.map

package/lib/lockfileFormatConverters.d.ts

@@ -1,3 +1,3 @@
-import { type LockfileObject, type LockfileFile } from '@pnpm/lockfile.types';
+import type { LockfileFile, LockfileObject } from '@pnpm/lockfile.types';
 export declare function convertToLockfileFile(lockfile: LockfileObject): LockfileFile;
 export declare function convertToLockfileObject(lockfile: LockfileFile): LockfileObject;

package/lib/lockfileFormatConverters.js

@@ -1,32 +1,21 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToLockfileFile = convertToLockfileFile;
-exports.convertToLockfileObject = convertToLockfileObject;
-const dependency_path_1 = require("@pnpm/dependency-path");
-const types_1 = require("@pnpm/types");
-const isEmpty_1 = __importDefault(require("ramda/src/isEmpty"));
-const map_1 = __importDefault(require("ramda/src/map"));
-const omit_1 = __importDefault(require("ramda/src/omit"));
-const pickBy_1 = __importDefault(require("ramda/src/pickBy"));
-const pick_1 = __importDefault(require("ramda/src/pick"));
-const constants_1 = require("@pnpm/constants");
-function convertToLockfileFile(lockfile) {
+import { LOCKFILE_VERSION } from '@pnpm/constants';
+import { refToRelative, removeSuffix } from '@pnpm/deps.path';
+import { DEPENDENCIES_FIELDS } from '@pnpm/types';
+import { isEmpty, map as _mapValues, omit, pick, pickBy } from 'ramda';
+export function convertToLockfileFile(lockfile) {
     const packages = {};
     const snapshots = {};
     for (const [depPath, pkg] of Object.entries(lockfile.packages ?? {})) {
-        snapshots[depPath] = (0, pick_1.default)([
+        snapshots[depPath] = pick([
             'dependencies',
             'optionalDependencies',
             'transitivePeerDependencies',
             'optional',
             'id',
         ], pkg);
-        const pkgId = (0, dependency_path_1.removeSuffix)(depPath);
+        const pkgId = removeSuffix(depPath);
         if (!packages[pkgId]) {
-            packages[pkgId] = (0, pick_1.default)([
+            packages[pkgId] = pick([
                 'bundledDependencies',
                 'cpu',
                 'deprecated',
@@ -46,11 +35,11 @@ function convertToLockfileFile(lockfile) {
         ...lockfile,
         snapshots,
         packages,
-        lockfileVersion: constants_1.LOCKFILE_VERSION,
+        lockfileVersion: LOCKFILE_VERSION,
         importers: mapValues(lockfile.importers, convertProjectSnapshotToInlineSpecifiersFormat),
     };
     if (newLockfile.settings?.peersSuffixMaxLength === 1000) {
-        newLockfile.settings = (0, omit_1.default)(['peersSuffixMaxLength'], newLockfile.settings);
+        newLockfile.settings = omit(['peersSuffixMaxLength'], newLockfile.settings);
     }
     if (newLockfile.settings?.injectWorkspacePackages === false) {
         delete newLockfile.settings.injectWorkspacePackages;
@@ -60,13 +49,13 @@ function convertToLockfileFile(lockfile) {
 function normalizeLockfile(lockfile) {
     const lockfileToSave = {
         ...lockfile,
-        importers: (0, map_1.default)((importer) => {
+        importers: _mapValues((importer) => {
             const normalizedImporter = {};
-            if (importer.dependenciesMeta != null && !(0, isEmpty_1.default)(importer.dependenciesMeta)) {
+            if (importer.dependenciesMeta != null && !isEmpty(importer.dependenciesMeta)) {
                 normalizedImporter.dependenciesMeta = importer.dependenciesMeta;
             }
-            for (const depType of types_1.DEPENDENCIES_FIELDS) {
-                if (!(0, isEmpty_1.default)(importer[depType] ?? {})) {
+            for (const depType of DEPENDENCIES_FIELDS) {
+                if (!isEmpty(importer[depType] ?? {})) {
                     normalizedImporter[depType] = importer[depType];
                 }
             }
@@ -76,22 +65,22 @@ function normalizeLockfile(lockfile) {
             return normalizedImporter;
         }, lockfile.importers ?? {}),
     };
-    if ((0, isEmpty_1.default)(lockfileToSave.packages) || (lockfileToSave.packages == null)) {
+    if (isEmpty(lockfileToSave.packages) || (lockfileToSave.packages == null)) {
         delete lockfileToSave.packages;
     }
-    if ((0, isEmpty_1.default)(lockfileToSave.snapshots) || (lockfileToSave.snapshots == null)) {
+    if (isEmpty(lockfileToSave.snapshots) || (lockfileToSave.snapshots == null)) {
         delete lockfileToSave.snapshots;
     }
     if (lockfileToSave.time) {
         lockfileToSave.time = pruneTimeInLockfile(lockfileToSave.time, lockfile.importers ?? {});
     }
-    if ((lockfileToSave.catalogs != null) && (0, isEmpty_1.default)(lockfileToSave.catalogs)) {
+    if ((lockfileToSave.catalogs != null) && isEmpty(lockfileToSave.catalogs)) {
         delete lockfileToSave.catalogs;
     }
-    if ((lockfileToSave.overrides != null) && (0, isEmpty_1.default)(lockfileToSave.overrides)) {
+    if ((lockfileToSave.overrides != null) && isEmpty(lockfileToSave.overrides)) {
         delete lockfileToSave.overrides;
     }
-    if ((lockfileToSave.patchedDependencies != null) && (0, isEmpty_1.default)(lockfileToSave.patchedDependencies)) {
+    if ((lockfileToSave.patchedDependencies != null) && isEmpty(lockfileToSave.patchedDependencies)) {
         delete lockfileToSave.patchedDependencies;
     }
     if (!lockfileToSave.packageExtensionsChecksum) {
@@ -108,7 +97,7 @@ function normalizeLockfile(lockfile) {
 function pruneTimeInLockfile(time, importers) {
     const rootDepPaths = new Set();
     for (const importer of Object.values(importers)) {
-        for (const depType of types_1.DEPENDENCIES_FIELDS) {
+        for (const depType of DEPENDENCIES_FIELDS) {
             for (const [depName, ref] of Object.entries(importer[depType] ?? {})) {
                 const suffixStart = ref.version.indexOf('(');
                 const refWithoutPeerDepGraphHash = suffixStart === -1 ? ref.version : ref.version.slice(0, suffixStart);
@@ -119,33 +108,31 @@ function pruneTimeInLockfile(time, importers) {
             }
         }
     }
-    return (0, pickBy_1.default)((_, depPath) => rootDepPaths.has(depPath), time);
+    return pickBy((_, depPath) => rootDepPaths.has(depPath), time);
 }
-function refToRelative(reference, pkgName) {
-    if (reference.startsWith('link:')) {
-        return null;
-    }
-    if (reference.startsWith('file:')) {
-        return reference;
-    }
-    if (!reference.includes('/') || !reference.replace(/(?:\([^)]+\))+$/, '').includes('/')) {
-        return `/${pkgName}@${reference}`;
-    }
-    return reference;
-}
-function convertToLockfileObject(lockfile) {
+export function convertToLockfileObject(lockfile) {
     const { importers, ...rest } = lockfile;
     const packages = {};
     for (const [depPath, pkg] of Object.entries(lockfile.snapshots ?? {})) {
-        const pkgId = (0, dependency_path_1.removeSuffix)(depPath);
+        const pkgId = removeSuffix(depPath);
         packages[depPath] = Object.assign(pkg, lockfile.packages?.[pkgId]);
     }
     return {
-        ...(0, omit_1.default)(['snapshots'], rest),
+        ...omit(['snapshots'], rest),
+        patchedDependencies: migratePatchedDependencies(rest.patchedDependencies),
         packages,
         importers: mapValues(importers ?? {}, revertProjectSnapshot),
     };
 }
+function migratePatchedDependencies(patchedDependencies) {
+    if (!patchedDependencies)
+        return undefined;
+    const result = {};
+    for (const [key, value] of Object.entries(patchedDependencies)) {
+        result[key] = typeof value === 'string' ? value : value.hash;
+    }
+    return result;
+}
 function convertProjectSnapshotToInlineSpecifiersFormat(projectSnapshot) {
     const { specifiers, ...rest } = projectSnapshot;
     if (specifiers == null)

package/lib/lockfileName.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWantedLockfileName = getWantedLockfileName;
-const constants_1 = require("@pnpm/constants");
-const git_utils_1 = require("@pnpm/git-utils");
-async function getWantedLockfileName(opts = { useGitBranchLockfile: false, mergeGitBranchLockfiles: false }) {
+import { WANTED_LOCKFILE } from '@pnpm/constants';
+import { getCurrentBranch } from '@pnpm/network.git-utils';
+export async function getWantedLockfileName(opts = { useGitBranchLockfile: false, mergeGitBranchLockfiles: false }) {
     if (opts.useGitBranchLockfile && !opts.mergeGitBranchLockfiles) {
-        const currentBranchName = await (0, git_utils_1.getCurrentBranch)();
+        const currentBranchName = await getCurrentBranch();
         if (currentBranchName) {
-            return constants_1.WANTED_LOCKFILE.replace('.yaml', `.${stringifyBranchName(currentBranchName)}.yaml`);
+            return WANTED_LOCKFILE.replace('.yaml', `.${stringifyBranchName(currentBranchName)}.yaml`);
         }
     }
-    return constants_1.WANTED_LOCKFILE;
+    return WANTED_LOCKFILE;
 }
 /**
  * 1. Git branch name may contains slashes, which is not allowed in filenames

package/lib/logger.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lockfileLogger = void 0;
-const logger_1 = require("@pnpm/logger");
-exports.lockfileLogger = (0, logger_1.logger)('lockfile');
+import { logger } from '@pnpm/logger';
+export const lockfileLogger = logger('lockfile');
 //# sourceMappingURL=logger.js.map

package/lib/read.d.ts

@@ -1,5 +1,5 @@
-import { type LockfileObject } from '@pnpm/lockfile.types';
-import { type ProjectId } from '@pnpm/types';
+import type { LockfileObject } from '@pnpm/lockfile.types';
+import type { ProjectId } from '@pnpm/types';
 export declare function readCurrentLockfile(pnpmInternalDir: string, opts: {
     wantedVersions?: string[];
     ignoreIncompatible: boolean;